Remove some dead bindings code

6 files changed, 64 insertions, 1394 deletions

diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index eae673343..15e15b032 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -339,6 +339,14 @@ pub const ZigString = extern struct {
         return out;
     }
 
+    pub fn fromUTF8(slice_: []const u8) ZigString {
+        var out = init(slice_);
+        if (strings.isAllASCII(slice_))
+            out.markUTF8();
+
+        return out;
+    }
+
     pub fn static(comptime slice_: []const u8) *const ZigString {
         const Holder = struct {
             pub const value = ZigString{ .ptr = slice_.ptr, .len = slice_.len };
@@ -1150,17 +1158,13 @@ pub const JSCell = extern struct {
         return shim.cppFn("getObject", .{this});
     }
 
-    pub fn getString(this: *JSCell, globalObject: *JSGlobalObject) String {
-        return shim.cppFn("getString", .{ this, globalObject });
-    }
-
     pub fn getType(this: *JSCell) u8 {
         return shim.cppFn("getType", .{
             this,
         });
     }
 
-    pub const Extern = [_][]const u8{ "getObject", "getString", "getType" };
+    pub const Extern = [_][]const u8{ "getObject", "getType" };
 };
 
 pub const JSString = extern struct {
@@ -1193,10 +1197,6 @@ pub const JSString = extern struct {
         return shim.cppFn("eql", .{ this, global, other });
     }
 
-    pub fn value(this: *JSString, globalObject: *JSGlobalObject) String {
-        return shim.cppFn("value", .{ this, globalObject });
-    }
-
     pub fn iterator(this: *JSString, globalObject: *JSGlobalObject, iter: *anyopaque) void {
         return shim.cppFn("iterator", .{ this, globalObject, iter });
     }
@@ -1213,18 +1213,6 @@ pub const JSString = extern struct {
         });
     }
 
-    pub fn createFromOwnedString(vm: *VM, str: *const String) *JSString {
-        return shim.cppFn("createFromOwnedString", .{
-            vm, str,
-        });
-    }
-
-    pub fn createFromString(vm: *VM, str: *const String) *JSString {
-        return shim.cppFn("createFromString", .{
-            vm, str,
-        });
-    }
-
     pub const JStringIteratorAppend8Callback = fn (*Iterator, [*]const u8, u32) callconv(.C) void;
     pub const JStringIteratorAppend16Callback = fn (*Iterator, [*]const u16, u32) callconv(.C) void;
     pub const JStringIteratorWrite8Callback = fn (*Iterator, [*]const u8, u32, u32) callconv(.C) void;
@@ -1246,48 +1234,6 @@ pub const JSPromiseRejectionOperation = enum(u32) {
     Handle = 1,
 };
 
-pub const ScriptArguments = extern struct {
-    pub const shim = Shimmer("Inspector", "ScriptArguments", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-    pub const include = "JavaScriptCore/ScriptArguments.h";
-    pub const name = "Inspector::ScriptArguments";
-    pub const namespace = "Inspector";
-
-    pub fn argumentAt(this: *ScriptArguments, i: usize) JSValue {
-        return cppFn("argumentAt", .{
-            this,
-            i,
-        });
-    }
-    pub fn argumentCount(this: *ScriptArguments) usize {
-        return cppFn("argumentCount", .{
-            this,
-        });
-    }
-    pub fn getFirstArgumentAsString(this: *ScriptArguments) String {
-        return cppFn("getFirstArgumentAsString", .{
-            this,
-        });
-    }
-
-    pub fn isEqual(this: *ScriptArguments, other: *ScriptArguments) bool {
-        return cppFn("isEqual", .{ this, other });
-    }
-
-    pub fn release(this: *ScriptArguments) void {
-        return cppFn("release", .{this});
-    }
-
-    pub const Extern = [_][]const u8{
-        "argumentAt",
-        "argumentCount",
-        "getFirstArgumentAsString",
-        "isEqual",
-        "release",
-    };
-};
-
 pub fn NewGlobalObject(comptime Type: type) type {
     return struct {
         const importNotImpl = "Import not implemented";
@@ -1327,19 +1273,6 @@ pub fn NewGlobalObject(comptime Type: type) type {
             return JSValue.jsUndefined();
         }
 
-        pub fn createImportMetaProperties(global: *JSGlobalObject, loader: *JSModuleLoader, obj: JSValue, record: *JSModuleRecord, specifier: JSValue) callconv(.C) JSValue {
-            if (comptime @hasDecl(Type, "createImportMetaProperties")) {
-                return @call(.{ .modifier = .always_inline }, Type.createImportMetaProperties, .{ global, loader, obj, record, specifier });
-            }
-            return JSValue.jsUndefined();
-        }
-
-        pub fn queueMicrotaskToEventLoop(global: *JSGlobalObject, microtask: *Microtask) callconv(.C) void {
-            if (comptime @hasDecl(Type, "queueMicrotaskToEventLoop")) {
-                @call(.{ .modifier = .always_inline }, Type.queueMicrotaskToEventLoop, .{ global, microtask });
-            }
-        }
-
         pub fn onCrash() callconv(.C) void {
             if (comptime @hasDecl(Type, "onCrash")) {
                 return @call(.{ .modifier = .always_inline }, Type.onCrash, .{});
@@ -1384,13 +1317,6 @@ pub const JSModuleLoader = extern struct {
         });
     }
 
-    pub fn loadAndEvaluateModuleEntryPoint(globalObject: *JSGlobalObject, source_code: *const SourceCode) *JSInternalPromise {
-        return shim.cppFn("loadAndEvaluateModuleEntryPoint", .{
-            globalObject,
-            source_code,
-        });
-    }
-
     pub fn loadAndEvaluateModule(globalObject: *JSGlobalObject, module_name: *const ZigString) *JSInternalPromise {
         return shim.cppFn("loadAndEvaluateModule", .{
             globalObject,
@@ -1398,39 +1324,14 @@ pub const JSModuleLoader = extern struct {
         });
     }
 
-    pub fn importModule(globalObject: *JSGlobalObject, key: *const Identifier) *JSInternalPromise {
-        return shim.cppFn("importModule", .{
-            globalObject,
-            key,
-        });
-    }
-
-    pub fn linkAndEvaluateModule(globalObject: *JSGlobalObject, key: *const Identifier) JSValue {
-        return shim.cppFn("linkAndEvaluateModule", .{
-            globalObject,
-            key,
-        });
-    }
-
-    pub fn checkSyntax(globalObject: *JSGlobalObject, source_code: *const SourceCode, is_module: bool) bool {
-        return shim.cppFn("checkSyntax", .{
-            globalObject,
-            source_code,
-            is_module,
-        });
-    }
-
     // pub fn dependencyKeysIfEvaluated(this: *JSModuleLoader, globalObject: *JSGlobalObject, moduleRecord: *JSModuleRecord) *JSValue {
     //     return shim.cppFn("dependencyKeysIfEvaluated", .{ this, globalObject, moduleRecord });
     // }
 
     pub const Extern = [_][]const u8{
-        // "dependencyKeysIfEvaluated",
         "evaluate",
-        "loadAndEvaluateModuleEntryPoint",
         "loadAndEvaluateModule",
         "importModule",
-        "linkAndEvaluateModule",
         "checkSyntax",
     };
 };
@@ -1450,25 +1351,6 @@ pub fn PromiseCallback(comptime Type: type, comptime CallbackFunction: fn (*Type
     }.callback;
 }
 
-pub const JSModuleRecord = extern struct {
-    pub const shim = Shimmer("JSC", "JSModuleRecord", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-    pub const include = "JavaScriptCore/JSModuleRecord.h";
-    pub const name = "JSC::JSModuleRecord";
-    pub const namespace = "JSC";
-
-    pub fn sourceCode(this: *JSModuleRecord) SourceCode {
-        return shim.cppFn("sourceCode", .{
-            this,
-        });
-    }
-
-    pub const Extern = [_][]const u8{
-        "sourceCode",
-    };
-};
-
 pub const JSPromise = extern struct {
     pub const shim = Shimmer("JSC", "JSPromise", @This());
     bytes: shim.Bytes,
@@ -1824,40 +1706,6 @@ pub const SourceType = enum(u8) {
     WebAssembly = 2,
 };
 
-pub const SourceOrigin = extern struct {
-    pub const shim = Shimmer("JSC", "SourceOrigin", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-    pub const include = "JavaScriptCore/SourceOrigin.h";
-    pub const name = "JSC::SourceOrigin";
-    pub const namespace = "JSC";
-
-    pub fn fromURL(url: *const URL) SourceOrigin {
-        return cppFn("fromURL", .{url});
-    }
-
-    pub const Extern = [_][]const u8{
-        "fromURL",
-    };
-};
-
-pub const SourceCode = extern struct {
-    pub const shim = Shimmer("JSC", "SourceCode", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-    pub const include = "JavaScriptCore/SourceProvider.h";
-    pub const name = "JSC::SourceCode";
-    pub const namespace = "JSC";
-
-    pub fn fromString(result: *SourceCode, source: *const String, origin: ?*const SourceOrigin, filename: ?*String, source_type: SourceType) void {
-        cppFn("fromString", .{ result, source, origin, filename, @enumToInt(source_type) });
-    }
-
-    pub const Extern = [_][]const u8{
-        "fromString",
-    };
-};
-
 pub const Thenables = opaque {};
 
 pub const JSFunction = extern struct {
@@ -1890,16 +1738,6 @@ pub const JSFunction = extern struct {
     //     });
     // }
 
-    pub fn getName(this: *JSFunction, vm: *VM) String {
-        return cppFn("getName", .{ this, vm });
-    }
-    pub fn displayName(this: *JSFunction, vm: *VM) String {
-        return cppFn("displayName", .{ this, vm });
-    }
-    pub fn calculatedDisplayName(this: *JSFunction, vm: *VM) String {
-        return cppFn("calculatedDisplayName", .{ this, vm });
-    }
-
     pub fn optimizeSoon(value: JSValue) void {
         cppFn("optimizeSoon", .{value});
     }
@@ -2062,79 +1900,6 @@ pub const JSGlobalObject = extern struct {
         return this;
     }
 
-    pub fn objectPrototype(this: *JSGlobalObject) *ObjectPrototype {
-        return cppFn("objectPrototype", .{this});
-    }
-    pub fn functionPrototype(this: *JSGlobalObject) *FunctionPrototype {
-        return cppFn("functionPrototype", .{this});
-    }
-    pub fn arrayPrototype(this: *JSGlobalObject) *ArrayPrototype {
-        return cppFn("arrayPrototype", .{this});
-    }
-    pub fn booleanPrototype(this: *JSGlobalObject) *JSObject {
-        return cppFn("booleanPrototype", .{this});
-    }
-    pub fn stringPrototype(this: *JSGlobalObject) *StringPrototype {
-        return cppFn("stringPrototype", .{this});
-    }
-    pub fn numberPrototype(this: *JSGlobalObject) *JSObject {
-        return cppFn("numberPrototype", .{this});
-    }
-    pub fn bigIntPrototype(this: *JSGlobalObject) *BigIntPrototype {
-        return cppFn("bigIntPrototype", .{this});
-    }
-    pub fn datePrototype(this: *JSGlobalObject) *JSObject {
-        return cppFn("datePrototype", .{this});
-    }
-    pub fn symbolPrototype(this: *JSGlobalObject) *JSObject {
-        return cppFn("symbolPrototype", .{this});
-    }
-    pub fn regExpPrototype(this: *JSGlobalObject) *RegExpPrototype {
-        return cppFn("regExpPrototype", .{this});
-    }
-    pub fn errorPrototype(this: *JSGlobalObject) *JSObject {
-        return cppFn("errorPrototype", .{this});
-    }
-    pub fn iteratorPrototype(this: *JSGlobalObject) *IteratorPrototype {
-        return cppFn("iteratorPrototype", .{this});
-    }
-    pub fn asyncIteratorPrototype(this: *JSGlobalObject) *AsyncIteratorPrototype {
-        return cppFn("asyncIteratorPrototype", .{this});
-    }
-    pub fn generatorFunctionPrototype(this: *JSGlobalObject) *GeneratorFunctionPrototype {
-        return cppFn("generatorFunctionPrototype", .{this});
-    }
-    pub fn generatorPrototype(this: *JSGlobalObject) *GeneratorPrototype {
-        return cppFn("generatorPrototype", .{this});
-    }
-    pub fn asyncFunctionPrototype(this: *JSGlobalObject) *AsyncFunctionPrototype {
-        return cppFn("asyncFunctionPrototype", .{this});
-    }
-    pub fn arrayIteratorPrototype(this: *JSGlobalObject) *ArrayIteratorPrototype {
-        return cppFn("arrayIteratorPrototype", .{this});
-    }
-    pub fn mapIteratorPrototype(this: *JSGlobalObject) *MapIteratorPrototype {
-        return cppFn("mapIteratorPrototype", .{this});
-    }
-    pub fn setIteratorPrototype(this: *JSGlobalObject) *SetIteratorPrototype {
-        return cppFn("setIteratorPrototype", .{this});
-    }
-    pub fn mapPrototype(this: *JSGlobalObject) *JSObject {
-        return cppFn("mapPrototype", .{this});
-    }
-    pub fn jsSetPrototype(this: *JSGlobalObject) *JSObject {
-        return cppFn("jsSetPrototype", .{this});
-    }
-    pub fn promisePrototype(this: *JSGlobalObject) *JSPromisePrototype {
-        return cppFn("promisePrototype", .{this});
-    }
-    pub fn asyncGeneratorPrototype(this: *JSGlobalObject) *AsyncGeneratorPrototype {
-        return cppFn("asyncGeneratorPrototype", .{this});
-    }
-    pub fn asyncGeneratorFunctionPrototype(this: *JSGlobalObject) *AsyncGeneratorFunctionPrototype {
-        return cppFn("asyncGeneratorFunctionPrototype", .{this});
-    }
-
     pub fn createAggregateError(globalObject: *JSGlobalObject, errors: [*]*anyopaque, errors_len: u16, message: *const ZigString) JSValue {
         return cppFn("createAggregateError", .{ globalObject, errors, errors_len, message });
     }
@@ -2220,31 +1985,9 @@ pub const JSGlobalObject = extern struct {
         "putCachedObject",
         "getCachedObject",
         "createAggregateError",
-        "objectPrototype",
-        "functionPrototype",
-        "arrayPrototype",
-        "booleanPrototype",
-        "stringPrototype",
-        "numberPrototype",
-        "bigIntPrototype",
-        "datePrototype",
-        "symbolPrototype",
-        "regExpPrototype",
-        "errorPrototype",
-        "iteratorPrototype",
-        "asyncIteratorPrototype",
+
         "deleteModuleRegistryEntry",
-        "generatorFunctionPrototype",
-        "generatorPrototype",
-        "asyncFunctionPrototype",
-        "arrayIteratorPrototype",
-        "mapIteratorPrototype",
-        "setIteratorPrototype",
-        "mapPrototype",
-        "jsSetPrototype",
-        "promisePrototype",
-        "asyncGeneratorPrototype",
-        "asyncGeneratorFunctionPrototype",
+
         "vm",
         "generateHeapSnapshot",
         "startRemoteInspector",
@@ -2255,144 +1998,8 @@ pub const JSGlobalObject = extern struct {
     };
 };
 
-fn _JSCellStub(comptime str: []const u8) type {
-    if (is_bindgen) {
-        return opaque {
-            pub const name = "JSC::" ++ str ++ "";
-        };
-    } else {
-        return opaque {};
-    }
-}
-
-fn _Bun(comptime str: []const u8) type {
-    if (is_bindgen) {
-        return opaque {
-            pub const name = "WebCore::" ++ str ++ "";
-        };
-    } else {
-        return opaque {};
-    }
-}
-
-fn _WTF(comptime str: []const u8) type {
-    if (is_bindgen) {
-        return opaque {
-            pub const name = "WTF::" ++ str ++ "";
-        };
-    } else {
-        return opaque {};
-    }
-}
 pub const JSNativeFn = fn (*JSGlobalObject, *CallFrame) callconv(.C) JSValue;
 
-pub const URL = extern struct {
-    pub const shim = Shimmer("WTF", "URL", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-    pub const include = "wtf/URL.h";
-    pub const name = "WTF::URL";
-    pub const namespace = "WTF";
-
-    pub fn fromString(base: String, relative: String) URL {
-        return cppFn("fromString", .{ base, relative });
-    }
-
-    pub fn fromFileSystemPath(result: *URL, file_system_path: StringView) void {
-        cppFn("fromFileSystemPath", .{ result, file_system_path });
-    }
-
-    pub fn isEmpty(this: *const URL) bool {
-        return cppFn("isEmpty", .{this});
-    }
-    pub fn isValid(this: *const URL) bool {
-        return cppFn("isValid", .{this});
-    }
-
-    pub fn protocol(this: *URL) StringView {
-        return cppFn("protocol", .{this});
-    }
-    pub fn encodedUser(this: *URL) StringView {
-        return cppFn("encodedUser", .{this});
-    }
-    pub fn encodedPassword(this: *URL) StringView {
-        return cppFn("encodedPassword", .{this});
-    }
-    pub fn host(this: *URL) StringView {
-        return cppFn("host", .{this});
-    }
-    pub fn path(this: *URL) StringView {
-        return cppFn("path", .{this});
-    }
-    pub fn lastPathComponent(this: *URL) StringView {
-        return cppFn("lastPathComponent", .{this});
-    }
-    pub fn query(this: *URL) StringView {
-        return cppFn("query", .{this});
-    }
-    pub fn fragmentIdentifier(this: *URL) StringView {
-        return cppFn("fragmentIdentifier", .{this});
-    }
-    pub fn queryWithLeadingQuestionMark(this: *URL) StringView {
-        return cppFn("queryWithLeadingQuestionMark", .{this});
-    }
-    pub fn fragmentIdentifierWithLeadingNumberSign(this: *URL) StringView {
-        return cppFn("fragmentIdentifierWithLeadingNumberSign", .{this});
-    }
-    pub fn stringWithoutQueryOrFragmentIdentifier(this: *URL) StringView {
-        return cppFn("stringWithoutQueryOrFragmentIdentifier", .{this});
-    }
-    pub fn stringWithoutFragmentIdentifier(this: *URL) String {
-        return cppFn("stringWithoutFragmentIdentifier", .{this});
-    }
-    pub fn protocolHostAndPort(this: *URL) String {
-        return cppFn("protocolHostAndPort", .{this});
-    }
-    pub fn hostAndPort(this: *URL) String {
-        return cppFn("hostAndPort", .{this});
-    }
-    pub fn user(this: *URL) String {
-        return cppFn("user", .{this});
-    }
-    pub fn password(this: *URL) String {
-        return cppFn("password", .{this});
-    }
-    pub fn fileSystemPath(this: *URL) String {
-        return cppFn("fileSystemPath", .{this});
-    }
-
-    pub fn setProtocol(this: *URL, protocol_value: StringView) void {
-        return cppFn("setProtocol", .{ this, protocol_value });
-    }
-    pub fn setHost(this: *URL, host_value: StringView) void {
-        return cppFn("setHost", .{ this, host_value });
-    }
-    pub fn setHostAndPort(this: *URL, host_and_port_value: StringView) void {
-        return cppFn("setHostAndPort", .{ this, host_and_port_value });
-    }
-    pub fn setUser(this: *URL, user_value: StringView) void {
-        return cppFn("setUser", .{ this, user_value });
-    }
-    pub fn setPassword(this: *URL, password_value: StringView) void {
-        return cppFn("setPassword", .{ this, password_value });
-    }
-    pub fn setPath(this: *URL, path_value: StringView) void {
-        return cppFn("setPath", .{ this, path_value });
-    }
-    pub fn setQuery(this: *URL, query_value: StringView) void {
-        return cppFn("setQuery", .{ this, query_value });
-    }
-
-    pub fn truncatedForUseAsBase(
-        this: *URL,
-    ) URL {
-        return cppFn("truncatedForUseAsBase", .{
-            this,
-        });
-    }
-    pub const Extern = [_][]const u8{ "fromFileSystemPath", "fromString", "isEmpty", "isValid", "protocol", "encodedUser", "encodedPassword", "host", "path", "lastPathComponent", "query", "fragmentIdentifier", "queryWithLeadingQuestionMark", "fragmentIdentifierWithLeadingNumberSign", "stringWithoutQueryOrFragmentIdentifier", "stringWithoutFragmentIdentifier", "protocolHostAndPort", "hostAndPort", "user", "password", "fileSystemPath", "setProtocol", "setHost", "setHostAndPort", "setUser", "setPassword", "setPath", "setQuery", "truncatedForUseAsBase" };
-};
-
 pub const JSArrayIterator = struct {
     i: u32 = 0,
     len: u32 = 0,
@@ -2417,93 +2024,6 @@ pub const JSArrayIterator = struct {
     }
 };
 
-pub const String = extern struct {
-    pub const shim = Shimmer("WTF", "String", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-    pub const include = "wtf/text/WTFString.h";
-    pub const name = "WTF::String";
-    pub const namespace = "WTF";
-
-    pub fn createWithoutCopyingFromPtr(out: *String, str: [*c]const u8, len: usize) void {
-        return cppFn("createWithoutCopyingFromPtr", .{ out, str, len });
-    }
-
-    pub fn createFromExternalString(str: ExternalStringImpl) String {
-        return cppFn("createFromExternalString", .{
-            str,
-        });
-    }
-
-    pub fn createWithoutCopying(str: []const u8) String {
-        var bytes = String{ .bytes = undefined };
-        @call(.{ .modifier = .always_inline }, createWithoutCopyingFromPtr, .{ &bytes, str.ptr, str.len });
-        return bytes;
-    }
-
-    pub fn is8Bit(this: *String) bool {
-        return cppFn("is8Bit", .{this});
-    }
-    pub fn is16Bit(this: *String) bool {
-        return cppFn("is16Bit", .{this});
-    }
-    pub fn isExternal(this: *String) bool {
-        return cppFn("isExternal", .{this});
-    }
-    pub fn isStatic(this: *String) bool {
-        return cppFn("isStatic", .{this});
-    }
-    pub fn isEmpty(this: *String) bool {
-        return cppFn("isEmpty", .{this});
-    }
-    pub fn length(this: *String) usize {
-        return cppFn("length", .{this});
-    }
-    pub fn characters8(this: *String) [*]const u8 {
-        return cppFn("characters8", .{this});
-    }
-    pub fn characters16(this: *String) [*]const u16 {
-        return cppFn("characters16", .{this});
-    }
-
-    pub fn eqlString(this: *String, other: *const String) bool {
-        return cppFn("eqlString", .{ this, other });
-    }
-
-    pub fn eqlSlice(this: *String, other: [*]const u8, other_len: usize) bool {
-        return cppFn("eqlSlice", .{ this, other, other_len });
-    }
-
-    pub fn impl(
-        this: *String,
-    ) *const StringImpl {
-        return cppFn("impl", .{
-            this,
-        });
-    }
-
-    pub fn slice(this: *String) []const u8 {
-        const len = this.length();
-        return if (len > 0) this.characters8()[0..len] else "";
-    }
-
-    pub const Extern = [_][]const u8{
-        "is8Bit",
-        "is16Bit",
-        "isExternal",
-        "isStatic",
-        "isEmpty",
-        "length",
-        "characters8",
-        "characters16",
-        "createWithoutCopyingFromPtr",
-        "eqlString",
-        "eqlSlice",
-        "impl",
-        "createFromExternalString",
-    };
-};
-
 pub const JSValueReprInt = i64;
 pub const JSValue = enum(JSValueReprInt) {
     zero = 0,
@@ -3336,10 +2856,6 @@ pub const JSValue = enum(JSValueReprInt) {
         return cppFn("toString", .{ this, globalThis });
     }
 
-    pub fn toWTFString(this: JSValue, globalThis: *JSGlobalObject) String {
-        return cppFn("toWTFString", .{ this, globalThis });
-    }
-
     pub fn jsonStringify(this: JSValue, globalThis: *JSGlobalObject, indent: u32, out: *ZigString) void {
         return cppFn("jsonStringify", .{ this, globalThis, indent, out });
     }
@@ -3348,12 +2864,7 @@ pub const JSValue = enum(JSValueReprInt) {
     pub fn toStringOrNull(this: JSValue, globalThis: *JSGlobalObject) ?*JSString {
         return cppFn("toStringOrNull", .{ this, globalThis });
     }
-    pub fn toPropertyKey(this: JSValue, globalThis: *JSGlobalObject) Identifier {
-        return cppFn("toPropertyKey", .{ this, globalThis });
-    }
-    pub fn toPropertyKeyValue(this: JSValue, globalThis: *JSGlobalObject) JSValue {
-        return cppFn("toPropertyKeyValue", .{ this, globalThis });
-    }
+
     pub fn toObject(this: JSValue, globalThis: *JSGlobalObject) *JSObject {
         return cppFn("toObject", .{ this, globalThis });
     }
@@ -3654,7 +3165,7 @@ pub const JSValue = enum(JSValueReprInt) {
         return this.asNullableVoid().?;
     }
 
-    pub const Extern = [_][]const u8{ "forEachProperty", "coerceToInt32", "fastGet_", "getStaticProperty", "createUninitializedUint8Array", "fromInt64NoTruncate", "fromUInt64NoTruncate", "toUInt64NoTruncate", "asPromise", "toInt64", "_then", "put", "makeWithNameAndPrototype", "parseJSON", "symbolKeyFor", "symbolFor", "getSymbolDescription", "createInternalPromise", "asInternalPromise", "asArrayBuffer_", "fromEntries", "createTypeError", "createRangeError", "createObject2", "getIfPropertyExistsImpl", "jsType", "jsonStringify", "kind_", "isTerminationException", "isSameValue", "getLengthOfArray", "toZigString", "createStringArray", "createEmptyObject", "putRecord", "asPromise", "isClass", "getNameProperty", "getClassName", "getErrorsProperty", "toInt32", "toBoolean", "isInt32", "isIterable", "forEach", "isAggregateError", "toError", "toZigException", "isException", "toWTFString", "hasProperty", "getPropertyNames", "getDirect", "putDirect", "getIfExists", "asString", "asObject", "asNumber", "isError", "jsNull", "jsUndefined", "jsTDZValue", "jsBoolean", "jsDoubleNumber", "jsNumberFromDouble", "jsNumberFromChar", "jsNumberFromU16", "jsNumberFromInt64", "isBoolean", "isAnyInt", "isUInt32AsAnyInt", "isInt32AsAnyInt", "isNumber", "isString", "isBigInt", "isHeapBigInt", "isBigInt32", "isSymbol", "isPrimitive", "isGetterSetter", "isCustomGetterSetter", "isObject", "isCell", "asCell", "toString", "toStringOrNull", "toPropertyKey", "toPropertyKeyValue", "toObject", "toString", "getPrototype", "getPropertyByPropertyName", "eqlValue", "eqlCell", "isCallable", "toBooleanSlow", "deepEquals", "getIfPropertyExistsFromPath" };
+    pub const Extern = [_][]const u8{ "forEachProperty", "coerceToInt32", "fastGet_", "getStaticProperty", "createUninitializedUint8Array", "fromInt64NoTruncate", "fromUInt64NoTruncate", "toUInt64NoTruncate", "asPromise", "toInt64", "_then", "put", "makeWithNameAndPrototype", "parseJSON", "symbolKeyFor", "symbolFor", "getSymbolDescription", "createInternalPromise", "asInternalPromise", "asArrayBuffer_", "fromEntries", "createTypeError", "createRangeError", "createObject2", "getIfPropertyExistsImpl", "jsType", "jsonStringify", "kind_", "isTerminationException", "isSameValue", "getLengthOfArray", "toZigString", "createStringArray", "createEmptyObject", "putRecord", "asPromise", "isClass", "getNameProperty", "getClassName", "getErrorsProperty", "toInt32", "toBoolean", "isInt32", "isIterable", "forEach", "isAggregateError", "toError", "toZigException", "isException", "toWTFString", "hasProperty", "getPropertyNames", "getDirect", "putDirect", "getIfExists", "asString", "asObject", "asNumber", "isError", "jsNull", "jsUndefined", "jsTDZValue", "jsBoolean", "jsDoubleNumber", "jsNumberFromDouble", "jsNumberFromChar", "jsNumberFromU16", "jsNumberFromInt64", "isBoolean", "isAnyInt", "isUInt32AsAnyInt", "isInt32AsAnyInt", "isNumber", "isString", "isBigInt", "isHeapBigInt", "isBigInt32", "isSymbol", "isPrimitive", "isGetterSetter", "isCustomGetterSetter", "isObject", "isCell", "asCell", "toString", "toStringOrNull", "toPropertyKeyValue", "toObject", "toString", "getPrototype", "getPropertyByPropertyName", "eqlValue", "eqlCell", "isCallable", "toBooleanSlow", "deepEquals", "getIfPropertyExistsFromPath" };
 };
 
 extern "c" fn Microtask__run(*Microtask, *JSGlobalObject) void;
@@ -3683,39 +3194,6 @@ pub const MicrotaskForDefaultGlobalObject = opaque {
     }
 };
 
-pub const PropertyName = extern struct {
-    pub const shim = Shimmer("JSC", "PropertyName", @This());
-    bytes: shim.Bytes,
-
-    const cppFn = shim.cppFn;
-
-    pub const include = "JavaScriptCore/PropertyName.h";
-    pub const name = "JSC::PropertyName";
-    pub const namespace = "JSC";
-
-    pub fn eqlToPropertyName(property_name: *PropertyName, other: *const PropertyName) bool {
-        return cppFn("eqlToPropertyName", .{ property_name, other });
-    }
-
-    pub fn eqlToIdentifier(property_name: *PropertyName, other: *const Identifier) bool {
-        return cppFn("eqlToIdentifier", .{ property_name, other });
-    }
-
-    pub fn publicName(property_name: *PropertyName) ?*const StringImpl {
-        return cppFn("publicName", .{
-            property_name,
-        });
-    }
-
-    pub fn uid(property_name: *PropertyName) ?*const StringImpl {
-        return cppFn("uid", .{
-            property_name,
-        });
-    }
-
-    pub const Extern = [_][]const u8{ "eqlToPropertyName", "eqlToIdentifier", "publicName", "uid" };
-};
-
 pub const Exception = extern struct {
     pub const shim = Shimmer("JSC", "Exception", @This());
     bytes: shim.Bytes,
@@ -3755,26 +3233,6 @@ pub const Exception = extern struct {
     pub const Extern = [_][]const u8{ "create", "value", "getStackTrace" };
 };
 
-pub const JSLock = extern struct {
-    pub const shim = Shimmer("JSC", "Exception", @This());
-    bytes: shim.Bytes,
-
-    const cppFn = shim.cppFn;
-
-    pub const include = "JavaScriptCore/JSLock.h";
-    pub const name = "JSC::JSLock";
-    pub const namespace = "JSC";
-
-    pub fn lock(this: *JSLock) void {
-        return cppFn("lock", .{this});
-    }
-    pub fn unlock(this: *JSLock) void {
-        return cppFn("unlock", .{this});
-    }
-
-    pub const Extern = [_][]const u8{ "lock", "unlock" };
-};
-
 pub const VM = extern struct {
     pub const shim = Shimmer("JSC", "VM", @This());
     bytes: shim.Bytes,
@@ -4110,184 +3568,8 @@ pub const EncodedJSValue = extern union {
     asDouble: f64,
 };
 
-pub const Identifier = extern struct {
-    pub const shim = Shimmer("JSC", "Identifier", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-
-    pub const include = "JavaScriptCore/Identifier.h";
-    pub const name = "JSC::Identifier";
-    pub const namespace = "JSC";
-
-    pub fn fromString(vm: *VM, other: *const String) Identifier {
-        return cppFn("fromString", .{ vm, other });
-    }
-
-    pub fn fromSlice(vm: *VM, ptr: [*]const u8, len: usize) Identifier {
-        return cppFn("fromSlice", .{ vm, ptr, len });
-    }
-
-    // pub fn fromUid(vm: *VM, other: *const StringImpl) Identifier {
-    //     return cppFn("fromUid", .{ vm, other });
-    // }
-
-    pub fn deinit(this: *const Identifier) void {
-        return cppFn("deinit", .{this});
-    }
-
-    pub fn toString(identifier: *const Identifier) String {
-        return cppFn("toString", .{identifier});
-    }
-
-    pub fn length(identifier: *const Identifier) usize {
-        return cppFn("length", .{identifier});
-    }
-
-    pub fn isNull(this: *const Identifier) bool {
-        return cppFn("isNull", .{this});
-    }
-    pub fn isEmpty(this: *const Identifier) bool {
-        return cppFn("isEmpty", .{this});
-    }
-    pub fn isSymbol(this: *const Identifier) bool {
-        return cppFn("isSymbol", .{this});
-    }
-    pub fn isPrivateName(this: *const Identifier) bool {
-        return cppFn("isPrivateName", .{this});
-    }
-
-    pub fn eqlIdent(this: *const Identifier, other: *const Identifier) bool {
-        return cppFn("eqlIdent", .{ this, other });
-    }
-
-    pub fn neqlIdent(this: *const Identifier, other: *const Identifier) bool {
-        return cppFn("neqlIdent", .{ this, other });
-    }
-
-    pub fn eqlStringImpl(this: *const Identifier, other: *const StringImpl) bool {
-        return cppFn("eqlStringImpl", .{ this, other });
-    }
-
-    pub fn neqlStringImpl(this: *const Identifier, other: *const StringImpl) bool {
-        return cppFn("neqlStringImpl", .{ this, other });
-    }
-
-    pub fn eqlUTF8(this: *const Identifier, other: [*]const u8, other_len: usize) bool {
-        return cppFn("eqlUTF8", .{ this, other, other_len });
-    }
-
-    pub const Extern = [_][]const u8{
-        "fromString",
-        "fromSlice",
-        // "fromUid",
-        "deinit",
-        "toString",
-        "length",
-        "isNull",
-        "isEmpty",
-        "isSymbol",
-        "isPrivateName",
-        "eqlIdent",
-        "neqlIdent",
-        "eqlStringImpl",
-        "neqlStringImpl",
-        "eqlUTF8",
-    };
-};
-
 const DeinitFunction = fn (ctx: *anyopaque, buffer: [*]u8, len: usize) callconv(.C) void;
 
-pub const StringImpl = extern struct {
-    pub const shim = Shimmer("WTF", "StringImpl", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-
-    pub const include = "wtf/text/StringImpl.h";
-    pub const name = "WTF::StringImpl";
-    pub const namespace = "WTF";
-
-    pub fn is8Bit(this: *const StringImpl) bool {
-        return cppFn("is8Bit", .{this});
-    }
-    pub fn is16Bit(this: *const StringImpl) bool {
-        return cppFn("is16Bit", .{this});
-    }
-    pub fn isExternal(this: *const StringImpl) bool {
-        return cppFn("isExternal", .{this});
-    }
-    pub fn isStatic(this: *const StringImpl) bool {
-        return cppFn("isStatic", .{this});
-    }
-    pub fn isEmpty(this: *const StringImpl) bool {
-        return cppFn("isEmpty", .{this});
-    }
-    pub fn length(this: *const StringImpl) usize {
-        return cppFn("length", .{this});
-    }
-    pub fn characters8(this: *const StringImpl) [*]const u8 {
-        return cppFn("characters8", .{this});
-    }
-    pub fn characters16(this: *const StringImpl) [*]const u16 {
-        return cppFn("characters16", .{this});
-    }
-
-    pub const slice = SliceFn(@This());
-
-    pub const Extern = [_][]const u8{
-        "is8Bit",
-        "is16Bit",
-        "isExternal",
-        "isStatic",
-        "isEmpty",
-        "length",
-        "characters8",
-        "characters16",
-    };
-};
-
-pub const ExternalStringImpl = extern struct {
-    pub const shim = Shimmer("WTF", "ExternalStringImpl", @This());
-    bytes: shim.Bytes,
-    const cppFn = shim.cppFn;
-
-    pub const include = "wtf/text/ExternalStringImpl.h";
-    pub const name = "WTF::ExternalStringImpl";
-    pub const namespace = "WTF";
-
-    pub fn create(ptr: [*]const u8, len: usize, deinit: DeinitFunction) ExternalStringImpl {
-        return cppFn("create", .{ ptr, len, deinit });
-    }
-
-    pub fn is8Bit(this: *const ExternalStringImpl) bool {
-        return cppFn("is8Bit", .{this});
-    }
-    pub fn is16Bit(this: *const ExternalStringImpl) bool {
-        return cppFn("is16Bit", .{this});
-    }
-    pub fn isEmpty(this: *const ExternalStringImpl) bool {
-        return cppFn("isEmpty", .{this});
-    }
-    pub fn length(this: *const ExternalStringImpl) usize {
-        return cppFn("length", .{this});
-    }
-    pub fn characters8(this: *const ExternalStringImpl) [*]const u8 {
-        return cppFn("characters8", .{this});
-    }
-    pub fn characters16(this: *const ExternalStringImpl) [*]const u16 {
-        return cppFn("characters16", .{this});
-    }
-
-    pub const Extern = [_][]const u8{
-        "create",
-        "is8Bit",
-        "is16Bit",
-        "isEmpty",
-        "length",
-        "characters8",
-        "characters16",
-    };
-};
-
 pub const JSArray = struct {
     pub fn from(globalThis: *JSGlobalObject, arguments: []const JSC.JSValue) JSValue {
         return JSC.JSValue.c(JSC.C.JSObjectMakeArray(globalThis, arguments.len, @ptrCast(?[*]const JSC.C.JSObjectRef, arguments.ptr), null));
@@ -4381,89 +3663,6 @@ pub fn untrackFunction(
     return private.Bun__untrackFFIFunction(globalObject, value);
 }
 
-pub const ObjectPrototype = _JSCellStub("ObjectPrototype");
-pub const FunctionPrototype = _JSCellStub("FunctionPrototype");
-pub const ArrayPrototype = _JSCellStub("ArrayPrototype");
-pub const StringPrototype = _JSCellStub("StringPrototype");
-pub const BigIntPrototype = _JSCellStub("BigIntPrototype");
-pub const RegExpPrototype = _JSCellStub("RegExpPrototype");
-pub const IteratorPrototype = _JSCellStub("IteratorPrototype");
-pub const AsyncIteratorPrototype = _JSCellStub("AsyncIteratorPrototype");
-pub const GeneratorFunctionPrototype = _JSCellStub("GeneratorFunctionPrototype");
-pub const GeneratorPrototype = _JSCellStub("GeneratorPrototype");
-pub const AsyncFunctionPrototype = _JSCellStub("AsyncFunctionPrototype");
-pub const ArrayIteratorPrototype = _JSCellStub("ArrayIteratorPrototype");
-pub const MapIteratorPrototype = _JSCellStub("MapIteratorPrototype");
-pub const SetIteratorPrototype = _JSCellStub("SetIteratorPrototype");
-pub const JSPromisePrototype = _JSCellStub("JSPromisePrototype");
-pub const AsyncGeneratorPrototype = _JSCellStub("AsyncGeneratorPrototype");
-pub const AsyncGeneratorFunctionPrototype = _JSCellStub("AsyncGeneratorFunctionPrototype");
-pub fn SliceFn(comptime Type: type) type {
-    const SliceStruct = struct {
-        pub fn slice(this: *const Type) []const u8 {
-            if (this.isEmpty()) {
-                return "";
-            }
-
-            return this.characters8()[0..this.length()];
-        }
-    };
-
-    return @TypeOf(SliceStruct.slice);
-}
-
-pub const StringView = extern struct {
-    pub const shim = Shimmer("WTF", "StringView", @This());
-    bytes: u64,
-    bytesA: u64,
-    const cppFn = shim.cppFn;
-
-    pub const include = "wtf/text/StringView.h";
-    pub const name = "WTF::StringView";
-    pub const namespace = "WTF";
-
-    pub fn from8Bit(view: *StringView, ptr: [*]const u8, len: usize) void {
-        return cppFn("from8Bit", .{ view, ptr, len });
-    }
-
-    pub fn fromSlice(value: []const u8) StringView {
-        var view = std.mem.zeroes(StringView);
-        from8Bit(&view, value.ptr, value.len);
-        return view;
-    }
-
-    pub fn is8Bit(this: *const StringView) bool {
-        return cppFn("is8Bit", .{this});
-    }
-    pub fn is16Bit(this: *const StringView) bool {
-        return cppFn("is16Bit", .{this});
-    }
-    pub fn isEmpty(this: *const StringView) bool {
-        return cppFn("isEmpty", .{this});
-    }
-    pub fn length(this: *const StringView) usize {
-        return cppFn("length", .{this});
-    }
-    pub fn characters8(this: *const StringView) [*]const u8 {
-        return cppFn("characters8", .{this});
-    }
-    pub fn characters16(this: *const StringView) [*]const u16 {
-        return cppFn("characters16", .{this});
-    }
-
-    pub const slice = SliceFn(@This());
-
-    pub const Extern = [_][]const u8{
-        "from8Bit",
-        "is8Bit",
-        "is16Bit",
-        "isEmpty",
-        "length",
-        "characters8",
-        "characters16",
-    };
-};
-
 pub const WTF = struct {
     extern fn WTF__copyLCharsFromUCharSource(dest: [*]u8, source: *const anyopaque, len: usize) void;
     extern fn WTF__toBase64URLStringValue(bytes: [*]const u8, length: usize, globalObject: *JSGlobalObject) JSValue;
diff --git a/src/bun.js/bindings/exports.zig b/src/bun.js/bindings/exports.zig
index 1842e52e5..2387122dd 100644
--- a/src/bun.js/bindings/exports.zig
+++ b/src/bun.js/bindings/exports.zig
@@ -18,12 +18,11 @@ const string = bun.string;
 const JSValue = JSC.JSValue;
 const Output = bun.Output;
 const Environment = bun.Environment;
-const ScriptArguments = JSC.ScriptArguments;
+const ScriptArguments = opaque {};
 const JSPromise = JSC.JSPromise;
 const JSPromiseRejectionOperation = JSC.JSPromiseRejectionOperation;
 const Exception = JSC.Exception;
 const JSModuleLoader = JSC.JSModuleLoader;
-const JSModuleRecord = JSC.JSModuleRecord;
 const Microtask = JSC.Microtask;
 const JSPrivateDataPtr = @import("../base.zig").JSPrivateDataPtr;
 const Backtrace = @import("../../crash_reporter.zig");
@@ -88,13 +87,6 @@ pub const ZigGlobalObject = extern struct {
         return @call(.{ .modifier = .always_inline }, Interface.reportUncaughtException, .{ global, exception });
     }
 
-    pub fn createImportMetaProperties(global: *JSGlobalObject, loader: *JSModuleLoader, obj: JSValue, record: *JSModuleRecord, specifier: JSValue) callconv(.C) JSValue {
-        if (comptime is_bindgen) {
-            unreachable;
-        }
-        return @call(.{ .modifier = .always_inline }, Interface.createImportMetaProperties, .{ global, loader, obj, record, specifier });
-    }
-
     pub fn onCrash() callconv(.C) void {
         if (comptime is_bindgen) {
             unreachable;
@@ -102,13 +94,6 @@ pub const ZigGlobalObject = extern struct {
         return @call(.{ .modifier = .always_inline }, Interface.onCrash, .{});
     }
 
-    pub fn queueMicrotaskToEventLoop(global: *JSGlobalObject, microtask: *Microtask) callconv(.C) void {
-        if (comptime is_bindgen) {
-            unreachable;
-        }
-        return @call(.{ .modifier = .always_inline }, Interface.queueMicrotaskToEventLoop, .{ global, microtask });
-    }
-
     pub const Export = shim.exportFunctions(
         .{
             .@"import" = import,
@@ -117,9 +102,7 @@ pub const ZigGlobalObject = extern struct {
             // .@"eval" = eval,
             .@"promiseRejectionTracker" = promiseRejectionTracker,
             .@"reportUncaughtException" = reportUncaughtException,
-            .@"createImportMetaProperties" = createImportMetaProperties,
             .@"onCrash" = onCrash,
-            .@"queueMicrotaskToEventLoop" = queueMicrotaskToEventLoop,
         },
     );
 
@@ -131,9 +114,7 @@ pub const ZigGlobalObject = extern struct {
         @export(fetch, .{ .name = Export[2].symbol_name });
         @export(promiseRejectionTracker, .{ .name = Export[3].symbol_name });
         @export(reportUncaughtException, .{ .name = Export[4].symbol_name });
-        @export(createImportMetaProperties, .{ .name = Export[5].symbol_name });
-        @export(onCrash, .{ .name = Export[6].symbol_name });
-        @export(queueMicrotaskToEventLoop, .{ .name = Export[7].symbol_name });
+        @export(onCrash, .{ .name = Export[5].symbol_name });
     }
 };
 
diff --git a/src/bun.js/bindings/headers-cpp.h b/src/bun.js/bindings/headers-cpp.h
index f5e8576d6..e35afe0f0 100644
--- a/src/bun.js/bindings/headers-cpp.h
+++ b/src/bun.js/bindings/headers-cpp.h
@@ -1,4 +1,4 @@
-//-- AUTOGENERATED FILE -- 1669718575
+//-- AUTOGENERATED FILE -- 1669793662
 // clang-format off
 #pragma once
 
@@ -40,14 +40,6 @@ extern "C" const size_t JSC__JSCell_object_align_ = alignof(JSC::JSCell);
 extern "C" const size_t JSC__JSString_object_size_ = sizeof(JSC::JSString);
 extern "C" const size_t JSC__JSString_object_align_ = alignof(JSC::JSString);
 
-#ifndef INCLUDED_JavaScriptCore_ScriptArguments_h
-#define INCLUDED_JavaScriptCore_ScriptArguments_h
-#include "JavaScriptCore/ScriptArguments.h"
-#endif
-
-extern "C" const size_t Inspector__ScriptArguments_object_size_ = sizeof(Inspector::ScriptArguments);
-extern "C" const size_t Inspector__ScriptArguments_object_align_ = alignof(Inspector::ScriptArguments);
-
 #ifndef INCLUDED_JavaScriptCore_JSModuleLoader_h
 #define INCLUDED_JavaScriptCore_JSModuleLoader_h
 #include "JavaScriptCore/JSModuleLoader.h"
@@ -56,14 +48,6 @@ extern "C" const size_t Inspector__ScriptArguments_object_align_ = alignof(Inspe
 extern "C" const size_t JSC__JSModuleLoader_object_size_ = sizeof(JSC::JSModuleLoader);
 extern "C" const size_t JSC__JSModuleLoader_object_align_ = alignof(JSC::JSModuleLoader);
 
-#ifndef INCLUDED_JavaScriptCore_JSModuleRecord_h
-#define INCLUDED_JavaScriptCore_JSModuleRecord_h
-#include "JavaScriptCore/JSModuleRecord.h"
-#endif
-
-extern "C" const size_t JSC__JSModuleRecord_object_size_ = sizeof(JSC::JSModuleRecord);
-extern "C" const size_t JSC__JSModuleRecord_object_align_ = alignof(JSC::JSModuleRecord);
-
 #ifndef INCLUDED_JavaScriptCore_JSPromise_h
 #define INCLUDED_JavaScriptCore_JSPromise_h
 #include "JavaScriptCore/JSPromise.h"
@@ -80,22 +64,6 @@ extern "C" const size_t JSC__JSPromise_object_align_ = alignof(JSC::JSPromise);
 extern "C" const size_t JSC__JSInternalPromise_object_size_ = sizeof(JSC::JSInternalPromise);
 extern "C" const size_t JSC__JSInternalPromise_object_align_ = alignof(JSC::JSInternalPromise);
 
-#ifndef INCLUDED_JavaScriptCore_SourceOrigin_h
-#define INCLUDED_JavaScriptCore_SourceOrigin_h
-#include "JavaScriptCore/SourceOrigin.h"
-#endif
-
-extern "C" const size_t JSC__SourceOrigin_object_size_ = sizeof(JSC::SourceOrigin);
-extern "C" const size_t JSC__SourceOrigin_object_align_ = alignof(JSC::SourceOrigin);
-
-#ifndef INCLUDED_JavaScriptCore_SourceProvider_h
-#define INCLUDED_JavaScriptCore_SourceProvider_h
-#include "JavaScriptCore/SourceProvider.h"
-#endif
-
-extern "C" const size_t JSC__SourceCode_object_size_ = sizeof(JSC::SourceCode);
-extern "C" const size_t JSC__SourceCode_object_align_ = alignof(JSC::SourceCode);
-
 #ifndef INCLUDED_JavaScriptCore_JSFunction_h
 #define INCLUDED_JavaScriptCore_JSFunction_h
 #include "JavaScriptCore/JSFunction.h"
@@ -112,22 +80,6 @@ extern "C" const size_t JSC__JSFunction_object_align_ = alignof(JSC::JSFunction)
 extern "C" const size_t JSC__JSGlobalObject_object_size_ = sizeof(JSC::JSGlobalObject);
 extern "C" const size_t JSC__JSGlobalObject_object_align_ = alignof(JSC::JSGlobalObject);
 
-#ifndef INCLUDED_wtf_URL_h
-#define INCLUDED_wtf_URL_h
-#include "wtf/URL.h"
-#endif
-
-extern "C" const size_t WTF__URL_object_size_ = sizeof(WTF::URL);
-extern "C" const size_t WTF__URL_object_align_ = alignof(WTF::URL);
-
-#ifndef INCLUDED_wtf_text_WTFString_h
-#define INCLUDED_wtf_text_WTFString_h
-#include "wtf/text/WTFString.h"
-#endif
-
-extern "C" const size_t WTF__String_object_size_ = sizeof(WTF::String);
-extern "C" const size_t WTF__String_object_align_ = alignof(WTF::String);
-
 #ifndef INCLUDED_JavaScriptCore_JSValue_h
 #define INCLUDED_JavaScriptCore_JSValue_h
 #include "JavaScriptCore/JSValue.h"
@@ -136,14 +88,6 @@ extern "C" const size_t WTF__String_object_align_ = alignof(WTF::String);
 extern "C" const size_t JSC__JSValue_object_size_ = sizeof(JSC::JSValue);
 extern "C" const size_t JSC__JSValue_object_align_ = alignof(JSC::JSValue);
 
-#ifndef INCLUDED_JavaScriptCore_PropertyName_h
-#define INCLUDED_JavaScriptCore_PropertyName_h
-#include "JavaScriptCore/PropertyName.h"
-#endif
-
-extern "C" const size_t JSC__PropertyName_object_size_ = sizeof(JSC::PropertyName);
-extern "C" const size_t JSC__PropertyName_object_align_ = alignof(JSC::PropertyName);
-
 #ifndef INCLUDED_JavaScriptCore_Exception_h
 #define INCLUDED_JavaScriptCore_Exception_h
 #include "JavaScriptCore/Exception.h"
@@ -176,38 +120,6 @@ extern "C" const size_t JSC__ThrowScope_object_align_ = alignof(JSC::ThrowScope)
 extern "C" const size_t JSC__CatchScope_object_size_ = sizeof(JSC::CatchScope);
 extern "C" const size_t JSC__CatchScope_object_align_ = alignof(JSC::CatchScope);
 
-#ifndef INCLUDED_JavaScriptCore_Identifier_h
-#define INCLUDED_JavaScriptCore_Identifier_h
-#include "JavaScriptCore/Identifier.h"
-#endif
-
-extern "C" const size_t JSC__Identifier_object_size_ = sizeof(JSC::Identifier);
-extern "C" const size_t JSC__Identifier_object_align_ = alignof(JSC::Identifier);
-
-#ifndef INCLUDED_wtf_text_StringImpl_h
-#define INCLUDED_wtf_text_StringImpl_h
-#include "wtf/text/StringImpl.h"
-#endif
-
-extern "C" const size_t WTF__StringImpl_object_size_ = sizeof(WTF::StringImpl);
-extern "C" const size_t WTF__StringImpl_object_align_ = alignof(WTF::StringImpl);
-
-#ifndef INCLUDED_wtf_text_ExternalStringImpl_h
-#define INCLUDED_wtf_text_ExternalStringImpl_h
-#include "wtf/text/ExternalStringImpl.h"
-#endif
-
-extern "C" const size_t WTF__ExternalStringImpl_object_size_ = sizeof(WTF::ExternalStringImpl);
-extern "C" const size_t WTF__ExternalStringImpl_object_align_ = alignof(WTF::ExternalStringImpl);
-
-#ifndef INCLUDED_wtf_text_StringView_h
-#define INCLUDED_wtf_text_StringView_h
-#include "wtf/text/StringView.h"
-#endif
-
-extern "C" const size_t WTF__StringView_object_size_ = sizeof(WTF::StringView);
-extern "C" const size_t WTF__StringView_object_align_ = alignof(WTF::StringView);
-
 #ifndef INCLUDED__ZigGlobalObject_h_
 #define INCLUDED__ZigGlobalObject_h_
 #include ""ZigGlobalObject.h""
@@ -240,8 +152,8 @@ extern "C" const size_t Zig__ConsoleClient_object_align_ = alignof(Zig::ConsoleC
 extern "C" const size_t Bun__Timer_object_size_ = sizeof(Bun__Timer);
 extern "C" const size_t Bun__Timer_object_align_ = alignof(Bun__Timer);
 
-const size_t sizes[48] = {sizeof(JSC::JSObject), sizeof(WebCore::DOMURL), sizeof(WebCore::FetchHeaders), sizeof(SystemError), sizeof(JSC::JSCell), sizeof(JSC::JSString), sizeof(Inspector::ScriptArguments), sizeof(JSC::JSModuleLoader), sizeof(JSC::JSModuleRecord), sizeof(JSC::JSPromise), sizeof(JSC::JSInternalPromise), sizeof(JSC::SourceOrigin), sizeof(JSC::SourceCode), sizeof(JSC::JSFunction), sizeof(JSC::JSGlobalObject), sizeof(WTF::URL), sizeof(WTF::String), sizeof(JSC::JSValue), sizeof(JSC::PropertyName), sizeof(JSC::Exception), sizeof(JSC::VM), sizeof(JSC::ThrowScope), sizeof(JSC::CatchScope), sizeof(JSC::Identifier), sizeof(WTF::StringImpl), sizeof(WTF::ExternalStringImpl), sizeof(WTF::StringView), sizeof(FFI__ptr), sizeof(Reader__u8), sizeof(Reader__u16), sizeof(Reader__u32), sizeof(Reader__ptr), sizeof(Reader__i8), sizeof(Reader__i16), sizeof(Reader__i32), sizeof(Reader__f32), sizeof(Reader__f64), sizeof(Reader__i64), sizeof(Reader__u64), sizeof(Reader__intptr), sizeof(Crypto__getRandomValues), sizeof(Crypto__randomUUID), sizeof(Zig::GlobalObject), sizeof(Bun__Path), sizeof(ArrayBufferSink), sizeof(HTTPSResponseSink), sizeof(HTTPResponseSink), sizeof(FileSink)};
+const size_t sizes[37] = {sizeof(JSC::JSObject), sizeof(WebCore::DOMURL), sizeof(WebCore::FetchHeaders), sizeof(SystemError), sizeof(JSC::JSCell), sizeof(JSC::JSString), sizeof(JSC::JSModuleLoader), sizeof(JSC::JSPromise), sizeof(JSC::JSInternalPromise), sizeof(JSC::JSFunction), sizeof(JSC::JSGlobalObject), sizeof(JSC::JSValue), sizeof(JSC::Exception), sizeof(JSC::VM), sizeof(JSC::ThrowScope), sizeof(JSC::CatchScope), sizeof(FFI__ptr), sizeof(Reader__u8), sizeof(Reader__u16), sizeof(Reader__u32), sizeof(Reader__ptr), sizeof(Reader__i8), sizeof(Reader__i16), sizeof(Reader__i32), sizeof(Reader__f32), sizeof(Reader__f64), sizeof(Reader__i64), sizeof(Reader__u64), sizeof(Reader__intptr), sizeof(Crypto__getRandomValues), sizeof(Crypto__randomUUID), sizeof(Zig::GlobalObject), sizeof(Bun__Path), sizeof(ArrayBufferSink), sizeof(HTTPSResponseSink), sizeof(HTTPResponseSink), sizeof(FileSink)};
 
-const char* names[48] = {"JSC__JSObject", "WebCore__DOMURL", "WebCore__FetchHeaders", "SystemError", "JSC__JSCell", "JSC__JSString", "Inspector__ScriptArguments", "JSC__JSModuleLoader", "JSC__JSModuleRecord", "JSC__JSPromise", "JSC__JSInternalPromise", "JSC__SourceOrigin", "JSC__SourceCode", "JSC__JSFunction", "JSC__JSGlobalObject", "WTF__URL", "WTF__String", "JSC__JSValue", "JSC__PropertyName", "JSC__Exception", "JSC__VM", "JSC__ThrowScope", "JSC__CatchScope", "JSC__Identifier", "WTF__StringImpl", "WTF__ExternalStringImpl", "WTF__StringView", "FFI__ptr", "Reader__u8", "Reader__u16", "Reader__u32", "Reader__ptr", "Reader__i8", "Reader__i16", "Reader__i32", "Reader__f32", "Reader__f64", "Reader__i64", "Reader__u64", "Reader__intptr", "Crypto__getRandomValues", "Crypto__randomUUID", "Zig__GlobalObject", "Bun__Path", "ArrayBufferSink", "HTTPSResponseSink", "HTTPResponseSink", "FileSink"};
+const char* names[37] = {"JSC__JSObject", "WebCore__DOMURL", "WebCore__FetchHeaders", "SystemError", "JSC__JSCell", "JSC__JSString", "JSC__JSModuleLoader", "JSC__JSPromise", "JSC__JSInternalPromise", "JSC__JSFunction", "JSC__JSGlobalObject", "JSC__JSValue", "JSC__Exception", "JSC__VM", "JSC__ThrowScope", "JSC__CatchScope", "FFI__ptr", "Reader__u8", "Reader__u16", "Reader__u32", "Reader__ptr", "Reader__i8", "Reader__i16", "Reader__i32", "Reader__f32", "Reader__f64", "Reader__i64", "Reader__u64", "Reader__intptr", "Crypto__getRandomValues", "Crypto__randomUUID", "Zig__GlobalObject", "Bun__Path", "ArrayBufferSink", "HTTPSResponseSink", "HTTPResponseSink", "FileSink"};
 
-const size_t aligns[48] = {alignof(JSC::JSObject), alignof(WebCore::DOMURL), alignof(WebCore::FetchHeaders), alignof(SystemError), alignof(JSC::JSCell), alignof(JSC::JSString), alignof(Inspector::ScriptArguments), alignof(JSC::JSModuleLoader), alignof(JSC::JSModuleRecord), alignof(JSC::JSPromise), alignof(JSC::JSInternalPromise), alignof(JSC::SourceOrigin), alignof(JSC::SourceCode), alignof(JSC::JSFunction), alignof(JSC::JSGlobalObject), alignof(WTF::URL), alignof(WTF::String), alignof(JSC::JSValue), alignof(JSC::PropertyName), alignof(JSC::Exception), alignof(JSC::VM), alignof(JSC::ThrowScope), alignof(JSC::CatchScope), alignof(JSC::Identifier), alignof(WTF::StringImpl), alignof(WTF::ExternalStringImpl), alignof(WTF::StringView), alignof(FFI__ptr), alignof(Reader__u8), alignof(Reader__u16), alignof(Reader__u32), alignof(Reader__ptr), alignof(Reader__i8), alignof(Reader__i16), alignof(Reader__i32), alignof(Reader__f32), alignof(Reader__f64), alignof(Reader__i64), alignof(Reader__u64), alignof(Reader__intptr), alignof(Crypto__getRandomValues), alignof(Crypto__randomUUID), alignof(Zig::GlobalObject), alignof(Bun__Path), alignof(ArrayBufferSink), alignof(HTTPSResponseSink), alignof(HTTPResponseSink), alignof(FileSink)};
+const size_t aligns[37] = {alignof(JSC::JSObject), alignof(WebCore::DOMURL), alignof(WebCore::FetchHeaders), alignof(SystemError), alignof(JSC::JSCell), alignof(JSC::JSString), alignof(JSC::JSModuleLoader), alignof(JSC::JSPromise), alignof(JSC::JSInternalPromise), alignof(JSC::JSFunction), alignof(JSC::JSGlobalObject), alignof(JSC::JSValue), alignof(JSC::Exception), alignof(JSC::VM), alignof(JSC::ThrowScope), alignof(JSC::CatchScope), alignof(FFI__ptr), alignof(Reader__u8), alignof(Reader__u16), alignof(Reader__u32), alignof(Reader__ptr), alignof(Reader__i8), alignof(Reader__i16), alignof(Reader__i32), alignof(Reader__f32), alignof(Reader__f64), alignof(Reader__i64), alignof(Reader__u64), alignof(Reader__intptr), alignof(Crypto__getRandomValues), alignof(Crypto__randomUUID), alignof(Zig::GlobalObject), alignof(Bun__Path), alignof(ArrayBufferSink), alignof(HTTPSResponseSink), alignof(HTTPResponseSink), alignof(FileSink)};
diff --git a/src/bun.js/bindings/headers-handwritten.h b/src/bun.js/bindings/headers-handwritten.h
index b8d071785..9e43f8881 100644
--- a/src/bun.js/bindings/headers-handwritten.h
+++ b/src/bun.js/bindings/headers-handwritten.h
@@ -273,4 +273,10 @@ extern "C" int64_t Bun__encoding__constructFromUTF16(void*, const UChar* ptr, si
 
 bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSC::JSValue v1, JSC::JSValue v2, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>& stack, JSC::ThrowScope* scope, bool addToStack);
 
+namespace JSC {
+class ScriptArguments;
+}
+
+using ScriptArguments = JSC::ScriptArguments;
+
 #endif
diff --git a/src/bun.js/bindings/headers.h b/src/bun.js/bindings/headers.h
index 663f4eadb..399fc54a6 100644
--- a/src/bun.js/bindings/headers.h
+++ b/src/bun.js/bindings/headers.h
@@ -1,5 +1,5 @@
 // clang-format off
-//-- AUTOGENERATED FILE -- 1669718575
+//-- AUTOGENERATED FILE -- 1669793662
 #pragma once
 
 #include <stddef.h>
@@ -26,227 +26,102 @@ typedef void* JSClassRef;
 #include "JavaScriptCore/JSClassRef.h"
 #endif
 #include "headers-handwritten.h"
- typedef struct bJSC__SourceCode { unsigned char bytes[24]; } bJSC__SourceCode;
- typedef char* bJSC__SourceCode_buf;
- typedef struct bWTF__URL { unsigned char bytes[40]; } bWTF__URL;
- typedef char* bWTF__URL_buf;
- typedef struct bJSC__JSModuleRecord { unsigned char bytes[216]; } bJSC__JSModuleRecord;
- typedef char* bJSC__JSModuleRecord_buf;
  typedef struct bJSC__ThrowScope { unsigned char bytes[8]; } bJSC__ThrowScope;
  typedef char* bJSC__ThrowScope_buf;
- typedef struct bJSC__PropertyName { unsigned char bytes[8]; } bJSC__PropertyName;
- typedef char* bJSC__PropertyName_buf;
- typedef struct bJSC__JSFunction { unsigned char bytes[32]; } bJSC__JSFunction;
- typedef char* bJSC__JSFunction_buf;
- typedef struct bJSC__JSGlobalObject { unsigned char bytes[3128]; } bJSC__JSGlobalObject;
- typedef char* bJSC__JSGlobalObject_buf;
- typedef struct bJSC__JSCell { unsigned char bytes[8]; } bJSC__JSCell;
- typedef char* bJSC__JSCell_buf;
- typedef struct bJSC__CatchScope { unsigned char bytes[8]; } bJSC__CatchScope;
- typedef char* bJSC__CatchScope_buf;
- typedef struct bWTF__String { unsigned char bytes[8]; } bWTF__String;
- typedef char* bWTF__String_buf;
- typedef struct bWTF__StringView { unsigned char bytes[16]; } bWTF__StringView;
- typedef char* bWTF__StringView_buf;
- typedef struct bJSC__JSModuleLoader { unsigned char bytes[16]; } bJSC__JSModuleLoader;
- typedef char* bJSC__JSModuleLoader_buf;
- typedef struct bInspector__ScriptArguments { unsigned char bytes[32]; } bInspector__ScriptArguments;
- typedef char* bInspector__ScriptArguments_buf;
  typedef struct bJSC__Exception { unsigned char bytes[40]; } bJSC__Exception;
  typedef char* bJSC__Exception_buf;
  typedef struct bJSC__VM { unsigned char bytes[52176]; } bJSC__VM;
  typedef char* bJSC__VM_buf;
  typedef struct bJSC__JSString { unsigned char bytes[16]; } bJSC__JSString;
  typedef char* bJSC__JSString_buf;
- typedef struct bJSC__SourceOrigin { unsigned char bytes[48]; } bJSC__SourceOrigin;
- typedef char* bJSC__SourceOrigin_buf;
- typedef struct bWTF__ExternalStringImpl { unsigned char bytes[40]; } bWTF__ExternalStringImpl;
- typedef char* bWTF__ExternalStringImpl_buf;
+ typedef struct bJSC__JSGlobalObject { unsigned char bytes[3128]; } bJSC__JSGlobalObject;
+ typedef char* bJSC__JSGlobalObject_buf;
+ typedef struct bJSC__JSCell { unsigned char bytes[8]; } bJSC__JSCell;
+ typedef char* bJSC__JSCell_buf;
  typedef struct bJSC__JSInternalPromise { unsigned char bytes[32]; } bJSC__JSInternalPromise;
  typedef char* bJSC__JSInternalPromise_buf;
- typedef struct bWTF__StringImpl { unsigned char bytes[24]; } bWTF__StringImpl;
- typedef char* bWTF__StringImpl_buf;
  typedef struct bJSC__JSPromise { unsigned char bytes[32]; } bJSC__JSPromise;
  typedef char* bJSC__JSPromise_buf;
  typedef struct bJSC__JSObject { unsigned char bytes[16]; } bJSC__JSObject;
  typedef char* bJSC__JSObject_buf;
- typedef struct bJSC__Identifier { unsigned char bytes[8]; } bJSC__Identifier;
- typedef char* bJSC__Identifier_buf;
+ typedef struct bJSC__CatchScope { unsigned char bytes[8]; } bJSC__CatchScope;
+ typedef char* bJSC__CatchScope_buf;
 
 #ifndef __cplusplus
  typedef bJSC__CatchScope JSC__CatchScope; // JSC::CatchScope
- typedef struct JSC__GeneratorPrototype JSC__GeneratorPrototype; // JSC::GeneratorPrototype
- typedef struct JSC__ArrayIteratorPrototype JSC__ArrayIteratorPrototype; // JSC::ArrayIteratorPrototype
   typedef ErrorableResolvedSource ErrorableResolvedSource;
- typedef struct JSC__JSPromisePrototype JSC__JSPromisePrototype; // JSC::JSPromisePrototype
+ typedef bJSC__ThrowScope JSC__ThrowScope; // JSC::ThrowScope
   typedef ErrorableZigString ErrorableZigString;
- typedef bJSC__PropertyName JSC__PropertyName; // JSC::PropertyName
  typedef bJSC__JSObject JSC__JSObject; // JSC::JSObject
   typedef WebSocketClient WebSocketClient;
- typedef bWTF__ExternalStringImpl WTF__ExternalStringImpl; // WTF::ExternalStringImpl
- typedef struct JSC__AsyncIteratorPrototype JSC__AsyncIteratorPrototype; // JSC::AsyncIteratorPrototype
- typedef bJSC__JSModuleLoader JSC__JSModuleLoader; // JSC::JSModuleLoader
- typedef struct JSC__AsyncGeneratorPrototype JSC__AsyncGeneratorPrototype; // JSC::AsyncGeneratorPrototype
- typedef struct JSC__AsyncGeneratorFunctionPrototype JSC__AsyncGeneratorFunctionPrototype; // JSC::AsyncGeneratorFunctionPrototype
-  typedef Uint8Array_alias Uint8Array_alias;
- typedef bJSC__Identifier JSC__Identifier; // JSC::Identifier
- typedef struct JSC__ArrayPrototype JSC__ArrayPrototype; // JSC::ArrayPrototype
-  typedef WebSocketClientTLS WebSocketClientTLS;
- typedef struct Zig__JSMicrotaskCallback Zig__JSMicrotaskCallback; // Zig::JSMicrotaskCallback
- typedef bJSC__JSPromise JSC__JSPromise; // JSC::JSPromise
-  typedef WebSocketHTTPClient WebSocketHTTPClient;
- typedef struct JSC__SetIteratorPrototype JSC__SetIteratorPrototype; // JSC::SetIteratorPrototype
-  typedef SystemError SystemError;
- typedef bJSC__JSCell JSC__JSCell; // JSC::JSCell
- typedef bJSC__SourceOrigin JSC__SourceOrigin; // JSC::SourceOrigin
- typedef bJSC__JSModuleRecord JSC__JSModuleRecord; // JSC::JSModuleRecord
- typedef bWTF__String WTF__String; // WTF::String
- typedef bWTF__URL WTF__URL; // WTF::URL
- typedef struct JSC__IteratorPrototype JSC__IteratorPrototype; // JSC::IteratorPrototype
- typedef bJSC__JSInternalPromise JSC__JSInternalPromise; // JSC::JSInternalPromise
- typedef struct JSC__RegExpPrototype JSC__RegExpPrototype; // JSC::RegExpPrototype
- typedef struct JSC__CallFrame JSC__CallFrame; // JSC::CallFrame
- typedef struct JSC__MapIteratorPrototype JSC__MapIteratorPrototype; // JSC::MapIteratorPrototype
- typedef struct WebCore__FetchHeaders WebCore__FetchHeaders; // WebCore::FetchHeaders
- typedef bWTF__StringView WTF__StringView; // WTF::StringView
- typedef bJSC__ThrowScope JSC__ThrowScope; // JSC::ThrowScope
- typedef bWTF__StringImpl WTF__StringImpl; // WTF::StringImpl
   typedef WebSocketHTTPSClient WebSocketHTTPSClient;
  typedef bJSC__VM JSC__VM; // JSC::VM
   typedef JSClassRef JSClassRef;
   typedef Bun__ArrayBuffer Bun__ArrayBuffer;
+  typedef Uint8Array_alias Uint8Array_alias;
+  typedef WebSocketClientTLS WebSocketClientTLS;
  typedef bJSC__JSGlobalObject JSC__JSGlobalObject; // JSC::JSGlobalObject
- typedef bJSC__JSFunction JSC__JSFunction; // JSC::JSFunction
- typedef struct JSC__AsyncFunctionPrototype JSC__AsyncFunctionPrototype; // JSC::AsyncFunctionPrototype
   typedef ZigException ZigException;
- typedef bJSC__SourceCode JSC__SourceCode; // JSC::SourceCode
- typedef struct JSC__BigIntPrototype JSC__BigIntPrototype; // JSC::BigIntPrototype
- typedef struct JSC__GeneratorFunctionPrototype JSC__GeneratorFunctionPrototype; // JSC::GeneratorFunctionPrototype
+ typedef bJSC__JSPromise JSC__JSPromise; // JSC::JSPromise
+  typedef WebSocketHTTPClient WebSocketHTTPClient;
+  typedef SystemError SystemError;
+ typedef bJSC__JSCell JSC__JSCell; // JSC::JSCell
   typedef ZigString ZigString;
  typedef struct WebCore__DOMURL WebCore__DOMURL; // WebCore::DOMURL
   typedef int64_t JSC__JSValue;
- typedef struct JSC__FunctionPrototype JSC__FunctionPrototype; // JSC::FunctionPrototype
- typedef bInspector__ScriptArguments Inspector__ScriptArguments; // Inspector::ScriptArguments
+ typedef bJSC__JSInternalPromise JSC__JSInternalPromise; // JSC::JSInternalPromise
  typedef bJSC__Exception JSC__Exception; // JSC::Exception
  typedef bJSC__JSString JSC__JSString; // JSC::JSString
- typedef struct JSC__ObjectPrototype JSC__ObjectPrototype; // JSC::ObjectPrototype
- typedef struct JSC__StringPrototype JSC__StringPrototype; // JSC::StringPrototype
+ typedef struct JSC__CallFrame JSC__CallFrame; // JSC::CallFrame
+ typedef struct WebCore__FetchHeaders WebCore__FetchHeaders; // WebCore::FetchHeaders
 
 #endif
 
 #ifdef __cplusplus
   namespace JSC {
     class JSCell;
-    class Exception;
-    class JSPromisePrototype;
-    class StringPrototype;
-    class GeneratorFunctionPrototype;
-    class ArrayPrototype;
-    class JSString;
     class JSObject;
-    class AsyncIteratorPrototype;
-    class AsyncGeneratorFunctionPrototype;
-    class Identifier;
+    class JSGlobalObject;
     class JSPromise;
-    class RegExpPrototype;
-    class AsyncFunctionPrototype;
+    class Exception;
+    class JSString;
+    class JSInternalPromise;
     class CatchScope;
     class VM;
-    class BigIntPrototype;
-    class SourceOrigin;
-    class ThrowScope;
-    class SetIteratorPrototype;
-    class AsyncGeneratorPrototype;
-    class PropertyName;
-    class MapIteratorPrototype;
-    class JSModuleRecord;
-    class JSInternalPromise;
-    class ArrayIteratorPrototype;
-    class JSFunction;
-    class JSModuleLoader;
-    class GeneratorPrototype;
-    class JSGlobalObject;
-    class SourceCode;
-    class FunctionPrototype;
-    class IteratorPrototype;
     class CallFrame;
-    class ObjectPrototype;
-  }
-  namespace WTF {
-    class URL;
-    class StringImpl;
-    class String;
-    class StringView;
-    class ExternalStringImpl;
-  }
-  namespace Zig {
-    class JSMicrotaskCallback;
+    class ThrowScope;
   }
   namespace WebCore {
     class DOMURL;
     class FetchHeaders;
   }
-  namespace Inspector {
-    class ScriptArguments;
-  }
 
   typedef ErrorableResolvedSource ErrorableResolvedSource;
   typedef ErrorableZigString ErrorableZigString;
   typedef WebSocketClient WebSocketClient;
-  typedef Uint8Array_alias Uint8Array_alias;
-  typedef WebSocketClientTLS WebSocketClientTLS;
-  typedef WebSocketHTTPClient WebSocketHTTPClient;
-  typedef SystemError SystemError;
   typedef WebSocketHTTPSClient WebSocketHTTPSClient;
   typedef JSClassRef JSClassRef;
   typedef Bun__ArrayBuffer Bun__ArrayBuffer;
+  typedef Uint8Array_alias Uint8Array_alias;
+  typedef WebSocketClientTLS WebSocketClientTLS;
   typedef ZigException ZigException;
+  typedef WebSocketHTTPClient WebSocketHTTPClient;
+  typedef SystemError SystemError;
   typedef ZigString ZigString;
   typedef int64_t JSC__JSValue;
   using JSC__JSCell = JSC::JSCell;
-  using JSC__Exception = JSC::Exception;
-  using JSC__JSPromisePrototype = JSC::JSPromisePrototype;
-  using JSC__StringPrototype = JSC::StringPrototype;
-  using JSC__GeneratorFunctionPrototype = JSC::GeneratorFunctionPrototype;
-  using JSC__ArrayPrototype = JSC::ArrayPrototype;
-  using JSC__JSString = JSC::JSString;
   using JSC__JSObject = JSC::JSObject;
-  using JSC__AsyncIteratorPrototype = JSC::AsyncIteratorPrototype;
-  using JSC__AsyncGeneratorFunctionPrototype = JSC::AsyncGeneratorFunctionPrototype;
-  using JSC__Identifier = JSC::Identifier;
+  using JSC__JSGlobalObject = JSC::JSGlobalObject;
   using JSC__JSPromise = JSC::JSPromise;
-  using JSC__RegExpPrototype = JSC::RegExpPrototype;
-  using JSC__AsyncFunctionPrototype = JSC::AsyncFunctionPrototype;
+  using JSC__Exception = JSC::Exception;
+  using JSC__JSString = JSC::JSString;
+  using JSC__JSInternalPromise = JSC::JSInternalPromise;
   using JSC__CatchScope = JSC::CatchScope;
   using JSC__VM = JSC::VM;
-  using JSC__BigIntPrototype = JSC::BigIntPrototype;
-  using JSC__SourceOrigin = JSC::SourceOrigin;
-  using JSC__ThrowScope = JSC::ThrowScope;
-  using JSC__SetIteratorPrototype = JSC::SetIteratorPrototype;
-  using JSC__AsyncGeneratorPrototype = JSC::AsyncGeneratorPrototype;
-  using JSC__PropertyName = JSC::PropertyName;
-  using JSC__MapIteratorPrototype = JSC::MapIteratorPrototype;
-  using JSC__JSModuleRecord = JSC::JSModuleRecord;
-  using JSC__JSInternalPromise = JSC::JSInternalPromise;
-  using JSC__ArrayIteratorPrototype = JSC::ArrayIteratorPrototype;
-  using JSC__JSFunction = JSC::JSFunction;
-  using JSC__JSModuleLoader = JSC::JSModuleLoader;
-  using JSC__GeneratorPrototype = JSC::GeneratorPrototype;
-  using JSC__JSGlobalObject = JSC::JSGlobalObject;
-  using JSC__SourceCode = JSC::SourceCode;
-  using JSC__FunctionPrototype = JSC::FunctionPrototype;
-  using JSC__IteratorPrototype = JSC::IteratorPrototype;
   using JSC__CallFrame = JSC::CallFrame;
-  using JSC__ObjectPrototype = JSC::ObjectPrototype;
-  using WTF__URL = WTF::URL;
-  using WTF__StringImpl = WTF::StringImpl;
-  using WTF__String = WTF::String;
-  using WTF__StringView = WTF::StringView;
-  using WTF__ExternalStringImpl = WTF::ExternalStringImpl;
-  using Zig__JSMicrotaskCallback = Zig::JSMicrotaskCallback;
+  using JSC__ThrowScope = JSC::ThrowScope;
   using WebCore__DOMURL = WebCore::DOMURL;
   using WebCore__FetchHeaders = WebCore::FetchHeaders;
-  using Inspector__ScriptArguments = Inspector::ScriptArguments;
 
 #endif
 
@@ -299,41 +174,21 @@ CPP_DECL JSC__JSValue SystemError__toErrorInstance(const SystemError* arg0, JSC_
 #pragma mark - JSC::JSCell
 
 CPP_DECL JSC__JSObject* JSC__JSCell__getObject(JSC__JSCell* arg0);
-CPP_DECL bWTF__String JSC__JSCell__getString(JSC__JSCell* arg0, JSC__JSGlobalObject* arg1);
 CPP_DECL unsigned char JSC__JSCell__getType(JSC__JSCell* arg0);
 
 #pragma mark - JSC::JSString
 
-CPP_DECL JSC__JSString* JSC__JSString__createFromOwnedString(JSC__VM* arg0, const WTF__String* arg1);
-CPP_DECL JSC__JSString* JSC__JSString__createFromString(JSC__VM* arg0, const WTF__String* arg1);
 CPP_DECL bool JSC__JSString__eql(const JSC__JSString* arg0, JSC__JSGlobalObject* arg1, JSC__JSString* arg2);
 CPP_DECL bool JSC__JSString__is8Bit(const JSC__JSString* arg0);
 CPP_DECL void JSC__JSString__iterator(JSC__JSString* arg0, JSC__JSGlobalObject* arg1, void* arg2);
 CPP_DECL size_t JSC__JSString__length(const JSC__JSString* arg0);
 CPP_DECL JSC__JSObject* JSC__JSString__toObject(JSC__JSString* arg0, JSC__JSGlobalObject* arg1);
 CPP_DECL void JSC__JSString__toZigString(JSC__JSString* arg0, JSC__JSGlobalObject* arg1, ZigString* arg2);
-CPP_DECL bWTF__String JSC__JSString__value(JSC__JSString* arg0, JSC__JSGlobalObject* arg1);
-
-#pragma mark - Inspector::ScriptArguments
-
-CPP_DECL JSC__JSValue Inspector__ScriptArguments__argumentAt(Inspector__ScriptArguments* arg0, size_t arg1);
-CPP_DECL size_t Inspector__ScriptArguments__argumentCount(Inspector__ScriptArguments* arg0);
-CPP_DECL bWTF__String Inspector__ScriptArguments__getFirstArgumentAsString(Inspector__ScriptArguments* arg0);
-CPP_DECL bool Inspector__ScriptArguments__isEqual(Inspector__ScriptArguments* arg0, Inspector__ScriptArguments* arg1);
-CPP_DECL void Inspector__ScriptArguments__release(Inspector__ScriptArguments* arg0);
 
 #pragma mark - JSC::JSModuleLoader
 
-CPP_DECL bool JSC__JSModuleLoader__checkSyntax(JSC__JSGlobalObject* arg0, const JSC__SourceCode* arg1, bool arg2);
 CPP_DECL JSC__JSValue JSC__JSModuleLoader__evaluate(JSC__JSGlobalObject* arg0, const unsigned char* arg1, size_t arg2, const unsigned char* arg3, size_t arg4, const unsigned char* arg5, size_t arg6, JSC__JSValue JSValue7, JSC__JSValue* arg8);
-CPP_DECL JSC__JSInternalPromise* JSC__JSModuleLoader__importModule(JSC__JSGlobalObject* arg0, const JSC__Identifier* arg1);
-CPP_DECL JSC__JSValue JSC__JSModuleLoader__linkAndEvaluateModule(JSC__JSGlobalObject* arg0, const JSC__Identifier* arg1);
 CPP_DECL JSC__JSInternalPromise* JSC__JSModuleLoader__loadAndEvaluateModule(JSC__JSGlobalObject* arg0, const ZigString* arg1);
-CPP_DECL JSC__JSInternalPromise* JSC__JSModuleLoader__loadAndEvaluateModuleEntryPoint(JSC__JSGlobalObject* arg0, const JSC__SourceCode* arg1);
-
-#pragma mark - JSC::JSModuleRecord
-
-CPP_DECL bJSC__SourceCode JSC__JSModuleRecord__sourceCode(JSC__JSModuleRecord* arg0);
 
 #pragma mark - JSC::JSPromise
 
@@ -366,107 +221,24 @@ CPP_DECL JSC__JSInternalPromise* JSC__JSInternalPromise__resolvedPromise(JSC__JS
 CPP_DECL JSC__JSValue JSC__JSInternalPromise__result(const JSC__JSInternalPromise* arg0, JSC__VM* arg1);
 CPP_DECL uint32_t JSC__JSInternalPromise__status(const JSC__JSInternalPromise* arg0, JSC__VM* arg1);
 
-#pragma mark - JSC::SourceOrigin
-
-CPP_DECL bJSC__SourceOrigin JSC__SourceOrigin__fromURL(const WTF__URL* arg0);
-
-#pragma mark - JSC::SourceCode
-
-CPP_DECL void JSC__SourceCode__fromString(JSC__SourceCode* arg0, const WTF__String* arg1, const JSC__SourceOrigin* arg2, WTF__String* arg3, unsigned char SourceType4);
-
 #pragma mark - JSC::JSFunction
 
-CPP_DECL bWTF__String JSC__JSFunction__calculatedDisplayName(JSC__JSFunction* arg0, JSC__VM* arg1);
-CPP_DECL bWTF__String JSC__JSFunction__displayName(JSC__JSFunction* arg0, JSC__VM* arg1);
-CPP_DECL bWTF__String JSC__JSFunction__getName(JSC__JSFunction* arg0, JSC__VM* arg1);
 CPP_DECL void JSC__JSFunction__optimizeSoon(JSC__JSValue JSValue0);
 
 #pragma mark - JSC::JSGlobalObject
 
-CPP_DECL JSC__ArrayIteratorPrototype* JSC__JSGlobalObject__arrayIteratorPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__ArrayPrototype* JSC__JSGlobalObject__arrayPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__AsyncFunctionPrototype* JSC__JSGlobalObject__asyncFunctionPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__AsyncGeneratorFunctionPrototype* JSC__JSGlobalObject__asyncGeneratorFunctionPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__AsyncGeneratorPrototype* JSC__JSGlobalObject__asyncGeneratorPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__AsyncIteratorPrototype* JSC__JSGlobalObject__asyncIteratorPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__BigIntPrototype* JSC__JSGlobalObject__bigIntPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__JSObject* JSC__JSGlobalObject__booleanPrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL VirtualMachine* JSC__JSGlobalObject__bunVM(JSC__JSGlobalObject* arg0);
 CPP_DECL JSC__JSValue JSC__JSGlobalObject__createAggregateError(JSC__JSGlobalObject* arg0, void** arg1, uint16_t arg2, const ZigString* arg3);
 CPP_DECL void JSC__JSGlobalObject__createSyntheticModule_(JSC__JSGlobalObject* arg0, ZigString* arg1, size_t arg2, JSC__JSValue* arg3, size_t arg4);
-CPP_DECL JSC__JSObject* JSC__JSGlobalObject__datePrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL void JSC__JSGlobalObject__deleteModuleRegistryEntry(JSC__JSGlobalObject* arg0, ZigString* arg1);
-CPP_DECL JSC__JSObject* JSC__JSGlobalObject__errorPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__FunctionPrototype* JSC__JSGlobalObject__functionPrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL JSC__JSValue JSC__JSGlobalObject__generateHeapSnapshot(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__GeneratorFunctionPrototype* JSC__JSGlobalObject__generatorFunctionPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__GeneratorPrototype* JSC__JSGlobalObject__generatorPrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL JSC__JSValue JSC__JSGlobalObject__getCachedObject(JSC__JSGlobalObject* arg0, const ZigString* arg1);
 CPP_DECL void JSC__JSGlobalObject__handleRejectedPromises(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__IteratorPrototype* JSC__JSGlobalObject__iteratorPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__JSObject* JSC__JSGlobalObject__jsSetPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__MapIteratorPrototype* JSC__JSGlobalObject__mapIteratorPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__JSObject* JSC__JSGlobalObject__mapPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__JSObject* JSC__JSGlobalObject__numberPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__ObjectPrototype* JSC__JSGlobalObject__objectPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__JSPromisePrototype* JSC__JSGlobalObject__promisePrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL JSC__JSValue JSC__JSGlobalObject__putCachedObject(JSC__JSGlobalObject* arg0, const ZigString* arg1, JSC__JSValue JSValue2);
-CPP_DECL JSC__RegExpPrototype* JSC__JSGlobalObject__regExpPrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL void JSC__JSGlobalObject__reload(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__SetIteratorPrototype* JSC__JSGlobalObject__setIteratorPrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL bool JSC__JSGlobalObject__startRemoteInspector(JSC__JSGlobalObject* arg0, unsigned char* arg1, uint16_t arg2);
-CPP_DECL JSC__StringPrototype* JSC__JSGlobalObject__stringPrototype(JSC__JSGlobalObject* arg0);
-CPP_DECL JSC__JSObject* JSC__JSGlobalObject__symbolPrototype(JSC__JSGlobalObject* arg0);
 CPP_DECL JSC__VM* JSC__JSGlobalObject__vm(JSC__JSGlobalObject* arg0);
 
-#pragma mark - WTF::URL
-
-CPP_DECL bWTF__StringView WTF__URL__encodedPassword(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__encodedUser(WTF__URL* arg0);
-CPP_DECL bWTF__String WTF__URL__fileSystemPath(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__fragmentIdentifier(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__fragmentIdentifierWithLeadingNumberSign(WTF__URL* arg0);
-CPP_DECL void WTF__URL__fromFileSystemPath(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL bWTF__URL WTF__URL__fromString(bWTF__String arg0, bWTF__String arg1);
-CPP_DECL bWTF__StringView WTF__URL__host(WTF__URL* arg0);
-CPP_DECL bWTF__String WTF__URL__hostAndPort(WTF__URL* arg0);
-CPP_DECL bool WTF__URL__isEmpty(const WTF__URL* arg0);
-CPP_DECL bool WTF__URL__isValid(const WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__lastPathComponent(WTF__URL* arg0);
-CPP_DECL bWTF__String WTF__URL__password(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__path(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__protocol(WTF__URL* arg0);
-CPP_DECL bWTF__String WTF__URL__protocolHostAndPort(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__query(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__queryWithLeadingQuestionMark(WTF__URL* arg0);
-CPP_DECL void WTF__URL__setHost(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL void WTF__URL__setHostAndPort(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL void WTF__URL__setPassword(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL void WTF__URL__setPath(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL void WTF__URL__setProtocol(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL void WTF__URL__setQuery(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL void WTF__URL__setUser(WTF__URL* arg0, bWTF__StringView arg1);
-CPP_DECL bWTF__String WTF__URL__stringWithoutFragmentIdentifier(WTF__URL* arg0);
-CPP_DECL bWTF__StringView WTF__URL__stringWithoutQueryOrFragmentIdentifier(WTF__URL* arg0);
-CPP_DECL bWTF__URL WTF__URL__truncatedForUseAsBase(WTF__URL* arg0);
-CPP_DECL bWTF__String WTF__URL__user(WTF__URL* arg0);
-
-#pragma mark - WTF::String
-
-CPP_DECL const uint16_t* WTF__String__characters16(WTF__String* arg0);
-CPP_DECL const unsigned char* WTF__String__characters8(WTF__String* arg0);
-CPP_DECL bWTF__String WTF__String__createFromExternalString(bWTF__ExternalStringImpl arg0);
-CPP_DECL void WTF__String__createWithoutCopyingFromPtr(WTF__String* arg0, const unsigned char* arg1, size_t arg2);
-CPP_DECL bool WTF__String__eqlSlice(WTF__String* arg0, const unsigned char* arg1, size_t arg2);
-CPP_DECL bool WTF__String__eqlString(WTF__String* arg0, const WTF__String* arg1);
-CPP_DECL const WTF__StringImpl* WTF__String__impl(WTF__String* arg0);
-CPP_DECL bool WTF__String__is16Bit(WTF__String* arg0);
-CPP_DECL bool WTF__String__is8Bit(WTF__String* arg0);
-CPP_DECL bool WTF__String__isEmpty(WTF__String* arg0);
-CPP_DECL bool WTF__String__isExternal(WTF__String* arg0);
-CPP_DECL bool WTF__String__isStatic(WTF__String* arg0);
-CPP_DECL size_t WTF__String__length(WTF__String* arg0);
-
 #pragma mark - JSC::JSValue
 
 CPP_DECL void JSC__JSValue___then(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__JSValue (* ArgFn3)(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1), JSC__JSValue (* ArgFn4)(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1));
@@ -550,23 +322,13 @@ CPP_DECL JSC__JSValue JSC__JSValue__toError(JSC__JSValue JSValue0, JSC__JSGlobal
 CPP_DECL int32_t JSC__JSValue__toInt32(JSC__JSValue JSValue0);
 CPP_DECL int64_t JSC__JSValue__toInt64(JSC__JSValue JSValue0);
 CPP_DECL JSC__JSObject* JSC__JSValue__toObject(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
-CPP_DECL bJSC__Identifier JSC__JSValue__toPropertyKey(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
-CPP_DECL JSC__JSValue JSC__JSValue__toPropertyKeyValue(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
 CPP_DECL JSC__JSString* JSC__JSValue__toString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
 CPP_DECL JSC__JSString* JSC__JSValue__toString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
 CPP_DECL JSC__JSString* JSC__JSValue__toStringOrNull(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
 CPP_DECL uint64_t JSC__JSValue__toUInt64NoTruncate(JSC__JSValue JSValue0);
-CPP_DECL bWTF__String JSC__JSValue__toWTFString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
 CPP_DECL void JSC__JSValue__toZigException(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, ZigException* arg2);
 CPP_DECL void JSC__JSValue__toZigString(JSC__JSValue JSValue0, ZigString* arg1, JSC__JSGlobalObject* arg2);
 
-#pragma mark - JSC::PropertyName
-
-CPP_DECL bool JSC__PropertyName__eqlToIdentifier(JSC__PropertyName* arg0, const JSC__Identifier* arg1);
-CPP_DECL bool JSC__PropertyName__eqlToPropertyName(JSC__PropertyName* arg0, const JSC__PropertyName* arg1);
-CPP_DECL const WTF__StringImpl* JSC__PropertyName__publicName(JSC__PropertyName* arg0);
-CPP_DECL const WTF__StringImpl* JSC__PropertyName__uid(JSC__PropertyName* arg0);
-
 #pragma mark - JSC::Exception
 
 CPP_DECL JSC__Exception* JSC__Exception__create(JSC__JSGlobalObject* arg0, JSC__JSObject* arg1, unsigned char StackCaptureAction2);
@@ -609,54 +371,6 @@ CPP_DECL void JSC__ThrowScope__release(JSC__ThrowScope* arg0);
 CPP_DECL void JSC__CatchScope__clearException(JSC__CatchScope* arg0);
 CPP_DECL bJSC__CatchScope JSC__CatchScope__declare(JSC__VM* arg0, unsigned char* arg1, unsigned char* arg2, size_t arg3);
 CPP_DECL JSC__Exception* JSC__CatchScope__exception(JSC__CatchScope* arg0);
-
-#pragma mark - JSC::Identifier
-
-CPP_DECL void JSC__Identifier__deinit(const JSC__Identifier* arg0);
-CPP_DECL bool JSC__Identifier__eqlIdent(const JSC__Identifier* arg0, const JSC__Identifier* arg1);
-CPP_DECL bool JSC__Identifier__eqlStringImpl(const JSC__Identifier* arg0, const WTF__StringImpl* arg1);
-CPP_DECL bool JSC__Identifier__eqlUTF8(const JSC__Identifier* arg0, const unsigned char* arg1, size_t arg2);
-CPP_DECL bJSC__Identifier JSC__Identifier__fromSlice(JSC__VM* arg0, const unsigned char* arg1, size_t arg2);
-CPP_DECL bJSC__Identifier JSC__Identifier__fromString(JSC__VM* arg0, const WTF__String* arg1);
-CPP_DECL bool JSC__Identifier__isEmpty(const JSC__Identifier* arg0);
-CPP_DECL bool JSC__Identifier__isNull(const JSC__Identifier* arg0);
-CPP_DECL bool JSC__Identifier__isPrivateName(const JSC__Identifier* arg0);
-CPP_DECL bool JSC__Identifier__isSymbol(const JSC__Identifier* arg0);
-CPP_DECL size_t JSC__Identifier__length(const JSC__Identifier* arg0);
-CPP_DECL bool JSC__Identifier__neqlIdent(const JSC__Identifier* arg0, const JSC__Identifier* arg1);
-CPP_DECL bool JSC__Identifier__neqlStringImpl(const JSC__Identifier* arg0, const WTF__StringImpl* arg1);
-CPP_DECL bWTF__String JSC__Identifier__toString(const JSC__Identifier* arg0);
-
-#pragma mark - WTF::StringImpl
-
-CPP_DECL const uint16_t* WTF__StringImpl__characters16(const WTF__StringImpl* arg0);
-CPP_DECL const unsigned char* WTF__StringImpl__characters8(const WTF__StringImpl* arg0);
-CPP_DECL bool WTF__StringImpl__is16Bit(const WTF__StringImpl* arg0);
-CPP_DECL bool WTF__StringImpl__is8Bit(const WTF__StringImpl* arg0);
-CPP_DECL bool WTF__StringImpl__isEmpty(const WTF__StringImpl* arg0);
-CPP_DECL bool WTF__StringImpl__isExternal(const WTF__StringImpl* arg0);
-CPP_DECL bool WTF__StringImpl__isStatic(const WTF__StringImpl* arg0);
-CPP_DECL size_t WTF__StringImpl__length(const WTF__StringImpl* arg0);
-
-#pragma mark - WTF::ExternalStringImpl
-
-CPP_DECL const uint16_t* WTF__ExternalStringImpl__characters16(const WTF__ExternalStringImpl* arg0);
-CPP_DECL const unsigned char* WTF__ExternalStringImpl__characters8(const WTF__ExternalStringImpl* arg0);
-CPP_DECL bWTF__ExternalStringImpl WTF__ExternalStringImpl__create(const unsigned char* arg0, size_t arg1, void (* ArgFn2)(void* arg0, unsigned char* arg1, size_t arg2));
-CPP_DECL bool WTF__ExternalStringImpl__is16Bit(const WTF__ExternalStringImpl* arg0);
-CPP_DECL bool WTF__ExternalStringImpl__is8Bit(const WTF__ExternalStringImpl* arg0);
-CPP_DECL bool WTF__ExternalStringImpl__isEmpty(const WTF__ExternalStringImpl* arg0);
-CPP_DECL size_t WTF__ExternalStringImpl__length(const WTF__ExternalStringImpl* arg0);
-
-#pragma mark - WTF::StringView
-
-CPP_DECL const uint16_t* WTF__StringView__characters16(const WTF__StringView* arg0);
-CPP_DECL const unsigned char* WTF__StringView__characters8(const WTF__StringView* arg0);
-CPP_DECL void WTF__StringView__from8Bit(WTF__StringView* arg0, const unsigned char* arg1, size_t arg2);
-CPP_DECL bool WTF__StringView__is16Bit(const WTF__StringView* arg0);
-CPP_DECL bool WTF__StringView__is8Bit(const WTF__StringView* arg0);
-CPP_DECL bool WTF__StringView__isEmpty(const WTF__StringView* arg0);
-CPP_DECL size_t WTF__StringView__length(const WTF__StringView* arg0);
 CPP_DECL void FFI__ptr__put(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
 
 #ifdef __cplusplus
@@ -786,12 +500,10 @@ CPP_DECL bool Zig__GlobalObject__resetModuleRegistryMap(JSC__JSGlobalObject* arg
 
 #ifdef __cplusplus
 
-ZIG_DECL JSC__JSValue Zig__GlobalObject__createImportMetaProperties(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSModuleRecord* arg3, JSC__JSValue JSValue4);
 ZIG_DECL void Zig__GlobalObject__fetch(ErrorableResolvedSource* arg0, JSC__JSGlobalObject* arg1, ZigString* arg2, ZigString* arg3);
 ZIG_DECL ErrorableZigString Zig__GlobalObject__import(JSC__JSGlobalObject* arg0, ZigString* arg1, ZigString* arg2);
 ZIG_DECL void Zig__GlobalObject__onCrash();
 ZIG_DECL JSC__JSValue Zig__GlobalObject__promiseRejectionTracker(JSC__JSGlobalObject* arg0, JSC__JSPromise* arg1, uint32_t JSPromiseRejectionOperation2);
-ZIG_DECL void Zig__GlobalObject__queueMicrotaskToEventLoop(JSC__JSGlobalObject* arg0, Zig__JSMicrotaskCallback* arg1);
 ZIG_DECL JSC__JSValue Zig__GlobalObject__reportUncaughtException(JSC__JSGlobalObject* arg0, JSC__Exception* arg1);
 ZIG_DECL void Zig__GlobalObject__resolve(ErrorableZigString* arg0, JSC__JSGlobalObject* arg1, ZigString* arg2, ZigString* arg3);
 
@@ -980,14 +692,14 @@ ZIG_DECL void Zig__ConsoleClient__countReset(void* arg0, JSC__JSGlobalObject* ar
 ZIG_DECL void Zig__ConsoleClient__messageWithTypeAndLevel(void* arg0, uint32_t MessageType1, uint32_t MessageLevel2, JSC__JSGlobalObject* arg3, JSC__JSValue* arg4, size_t arg5);
 ZIG_DECL void Zig__ConsoleClient__profile(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
 ZIG_DECL void Zig__ConsoleClient__profileEnd(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
-ZIG_DECL void Zig__ConsoleClient__record(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
-ZIG_DECL void Zig__ConsoleClient__recordEnd(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
-ZIG_DECL void Zig__ConsoleClient__screenshot(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
+ZIG_DECL void Zig__ConsoleClient__record(void* arg0, JSC__JSGlobalObject* arg1, ScriptArguments* arg2);
+ZIG_DECL void Zig__ConsoleClient__recordEnd(void* arg0, JSC__JSGlobalObject* arg1, ScriptArguments* arg2);
+ZIG_DECL void Zig__ConsoleClient__screenshot(void* arg0, JSC__JSGlobalObject* arg1, ScriptArguments* arg2);
 ZIG_DECL void Zig__ConsoleClient__takeHeapSnapshot(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
 ZIG_DECL void Zig__ConsoleClient__time(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
 ZIG_DECL void Zig__ConsoleClient__timeEnd(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
-ZIG_DECL void Zig__ConsoleClient__timeLog(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3, Inspector__ScriptArguments* arg4);
-ZIG_DECL void Zig__ConsoleClient__timeStamp(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
+ZIG_DECL void Zig__ConsoleClient__timeLog(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3, ScriptArguments* arg4);
+ZIG_DECL void Zig__ConsoleClient__timeStamp(void* arg0, JSC__JSGlobalObject* arg1, ScriptArguments* arg2);
 
 #endif
 
diff --git a/src/bun.js/bindings/headers.zig b/src/bun.js/bindings/headers.zig
index 8c83ed100..e99db7ef0 100644
--- a/src/bun.js/bindings/headers.zig
+++ b/src/bun.js/bindings/headers.zig
@@ -71,25 +71,13 @@ pub const WebSocketHTTPClient = bindings.WebSocketHTTPClient;
 pub const WebSocketHTTPSClient = bindings.WebSocketHTTPSClient;
 pub const WebSocketClient = bindings.WebSocketClient;
 pub const WebSocketClientTLS = bindings.WebSocketClientTLS;
-pub const JSC__PropertyName = bJSC__PropertyName;
+pub const JSC__ThrowScope = bJSC__ThrowScope;
 pub const JSC__JSObject = bJSC__JSObject;
-pub const WTF__ExternalStringImpl = bWTF__ExternalStringImpl;
-pub const JSC__JSModuleLoader = bJSC__JSModuleLoader;
-pub const JSC__Identifier = bJSC__Identifier;
+pub const JSC__VM = bJSC__VM;
+pub const JSC__JSGlobalObject = bJSC__JSGlobalObject;
 pub const JSC__JSPromise = bJSC__JSPromise;
 pub const JSC__JSCell = bJSC__JSCell;
-pub const JSC__SourceOrigin = bJSC__SourceOrigin;
-pub const JSC__JSModuleRecord = bJSC__JSModuleRecord;
-pub const WTF__String = bWTF__String;
-pub const WTF__URL = bWTF__URL;
 pub const JSC__JSInternalPromise = bJSC__JSInternalPromise;
-pub const WTF__StringView = bWTF__StringView;
-pub const JSC__ThrowScope = bJSC__ThrowScope;
-pub const WTF__StringImpl = bWTF__StringImpl;
-pub const JSC__VM = bJSC__VM;
-pub const JSC__JSGlobalObject = bJSC__JSGlobalObject;
-pub const JSC__JSFunction = bJSC__JSFunction;
-pub const JSC__SourceCode = bJSC__SourceCode;
 pub const JSC__Exception = bJSC__Exception;
 pub const JSC__JSString = bJSC__JSString;
 pub extern fn JSC__JSObject__create(arg0: ?*JSC__JSGlobalObject, arg1: usize, arg2: ?*anyopaque, ArgFn3: ?fn (?*anyopaque, [*c]JSC__JSObject, ?*JSC__JSGlobalObject) callconv(.C) void) JSC__JSValue;
@@ -132,29 +120,15 @@ pub extern fn WebCore__FetchHeaders__toJS(arg0: ?*bindings.FetchHeaders, arg1: ?
 pub extern fn WebCore__FetchHeaders__toUWSResponse(arg0: ?*bindings.FetchHeaders, arg1: bool, arg2: ?*anyopaque) void;
 pub extern fn SystemError__toErrorInstance(arg0: [*c]const SystemError, arg1: ?*JSC__JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__JSCell__getObject(arg0: [*c]JSC__JSCell) [*c]JSC__JSObject;
-pub extern fn JSC__JSCell__getString(arg0: [*c]JSC__JSCell, arg1: ?*JSC__JSGlobalObject) bWTF__String;
 pub extern fn JSC__JSCell__getType(arg0: [*c]JSC__JSCell) u8;
-pub extern fn JSC__JSString__createFromOwnedString(arg0: [*c]JSC__VM, arg1: [*c]const WTF__String) [*c]JSC__JSString;
-pub extern fn JSC__JSString__createFromString(arg0: [*c]JSC__VM, arg1: [*c]const WTF__String) [*c]JSC__JSString;
 pub extern fn JSC__JSString__eql(arg0: [*c]const JSC__JSString, arg1: ?*JSC__JSGlobalObject, arg2: [*c]JSC__JSString) bool;
 pub extern fn JSC__JSString__is8Bit(arg0: [*c]const JSC__JSString) bool;
 pub extern fn JSC__JSString__iterator(arg0: [*c]JSC__JSString, arg1: ?*JSC__JSGlobalObject, arg2: ?*anyopaque) void;
 pub extern fn JSC__JSString__length(arg0: [*c]const JSC__JSString) usize;
 pub extern fn JSC__JSString__toObject(arg0: [*c]JSC__JSString, arg1: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
 pub extern fn JSC__JSString__toZigString(arg0: [*c]JSC__JSString, arg1: ?*JSC__JSGlobalObject, arg2: [*c]ZigString) void;
-pub extern fn JSC__JSString__value(arg0: [*c]JSC__JSString, arg1: ?*JSC__JSGlobalObject) bWTF__String;
-pub extern fn Inspector__ScriptArguments__argumentAt(arg0: [*c]bindings.ScriptArguments, arg1: usize) JSC__JSValue;
-pub extern fn Inspector__ScriptArguments__argumentCount(arg0: [*c]bindings.ScriptArguments) usize;
-pub extern fn Inspector__ScriptArguments__getFirstArgumentAsString(arg0: [*c]bindings.ScriptArguments) bWTF__String;
-pub extern fn Inspector__ScriptArguments__isEqual(arg0: [*c]bindings.ScriptArguments, arg1: [*c]bindings.ScriptArguments) bool;
-pub extern fn Inspector__ScriptArguments__release(arg0: [*c]bindings.ScriptArguments) void;
-pub extern fn JSC__JSModuleLoader__checkSyntax(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const JSC__SourceCode, arg2: bool) bool;
 pub extern fn JSC__JSModuleLoader__evaluate(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const u8, arg2: usize, arg3: [*c]const u8, arg4: usize, arg5: [*c]const u8, arg6: usize, JSValue7: JSC__JSValue, arg8: [*c]JSC__JSValue) JSC__JSValue;
-pub extern fn JSC__JSModuleLoader__importModule(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const JSC__Identifier) [*c]JSC__JSInternalPromise;
-pub extern fn JSC__JSModuleLoader__linkAndEvaluateModule(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const JSC__Identifier) JSC__JSValue;
 pub extern fn JSC__JSModuleLoader__loadAndEvaluateModule(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const ZigString) [*c]JSC__JSInternalPromise;
-pub extern fn JSC__JSModuleLoader__loadAndEvaluateModuleEntryPoint(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const JSC__SourceCode) [*c]JSC__JSInternalPromise;
-pub extern fn JSC__JSModuleRecord__sourceCode(arg0: [*c]JSC__JSModuleRecord) bJSC__SourceCode;
 pub extern fn JSC__JSPromise__asValue(arg0: [*c]JSC__JSPromise, arg1: ?*JSC__JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__JSPromise__create(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSPromise;
 pub extern fn JSC__JSPromise__isHandled(arg0: [*c]const JSC__JSPromise, arg1: [*c]JSC__VM) bool;
@@ -180,89 +154,18 @@ pub extern fn JSC__JSInternalPromise__resolve(arg0: [*c]JSC__JSInternalPromise,
 pub extern fn JSC__JSInternalPromise__resolvedPromise(arg0: ?*JSC__JSGlobalObject, JSValue1: JSC__JSValue) [*c]JSC__JSInternalPromise;
 pub extern fn JSC__JSInternalPromise__result(arg0: [*c]const JSC__JSInternalPromise, arg1: [*c]JSC__VM) JSC__JSValue;
 pub extern fn JSC__JSInternalPromise__status(arg0: [*c]const JSC__JSInternalPromise, arg1: [*c]JSC__VM) u32;
-pub extern fn JSC__SourceOrigin__fromURL(arg0: [*c]const WTF__URL) bJSC__SourceOrigin;
-pub extern fn JSC__SourceCode__fromString(arg0: [*c]JSC__SourceCode, arg1: [*c]const WTF__String, arg2: [*c]const JSC__SourceOrigin, arg3: [*c]WTF__String, SourceType4: u8) void;
-pub extern fn JSC__JSFunction__calculatedDisplayName(arg0: [*c]JSC__JSFunction, arg1: [*c]JSC__VM) bWTF__String;
-pub extern fn JSC__JSFunction__displayName(arg0: [*c]JSC__JSFunction, arg1: [*c]JSC__VM) bWTF__String;
-pub extern fn JSC__JSFunction__getName(arg0: [*c]JSC__JSFunction, arg1: [*c]JSC__VM) bWTF__String;
 pub extern fn JSC__JSFunction__optimizeSoon(JSValue0: JSC__JSValue) void;
-pub extern fn JSC__JSGlobalObject__arrayIteratorPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.ArrayIteratorPrototype;
-pub extern fn JSC__JSGlobalObject__arrayPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.ArrayPrototype;
-pub extern fn JSC__JSGlobalObject__asyncFunctionPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.AsyncFunctionPrototype;
-pub extern fn JSC__JSGlobalObject__asyncGeneratorFunctionPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.AsyncGeneratorFunctionPrototype;
-pub extern fn JSC__JSGlobalObject__asyncGeneratorPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.AsyncGeneratorPrototype;
-pub extern fn JSC__JSGlobalObject__asyncIteratorPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.AsyncIteratorPrototype;
-pub extern fn JSC__JSGlobalObject__bigIntPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.BigIntPrototype;
-pub extern fn JSC__JSGlobalObject__booleanPrototype(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
 pub extern fn JSC__JSGlobalObject__bunVM(arg0: ?*JSC__JSGlobalObject) ?*bindings.VirtualMachine;
 pub extern fn JSC__JSGlobalObject__createAggregateError(arg0: ?*JSC__JSGlobalObject, arg1: [*c]*anyopaque, arg2: u16, arg3: [*c]const ZigString) JSC__JSValue;
 pub extern fn JSC__JSGlobalObject__createSyntheticModule_(arg0: ?*JSC__JSGlobalObject, arg1: [*c]ZigString, arg2: usize, arg3: [*c]JSC__JSValue, arg4: usize) void;
-pub extern fn JSC__JSGlobalObject__datePrototype(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
 pub extern fn JSC__JSGlobalObject__deleteModuleRegistryEntry(arg0: ?*JSC__JSGlobalObject, arg1: [*c]ZigString) void;
-pub extern fn JSC__JSGlobalObject__errorPrototype(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
-pub extern fn JSC__JSGlobalObject__functionPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.FunctionPrototype;
 pub extern fn JSC__JSGlobalObject__generateHeapSnapshot(arg0: ?*JSC__JSGlobalObject) JSC__JSValue;
-pub extern fn JSC__JSGlobalObject__generatorFunctionPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.GeneratorFunctionPrototype;
-pub extern fn JSC__JSGlobalObject__generatorPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.GeneratorPrototype;
 pub extern fn JSC__JSGlobalObject__getCachedObject(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const ZigString) JSC__JSValue;
 pub extern fn JSC__JSGlobalObject__handleRejectedPromises(arg0: ?*JSC__JSGlobalObject) void;
-pub extern fn JSC__JSGlobalObject__iteratorPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.IteratorPrototype;
-pub extern fn JSC__JSGlobalObject__jsSetPrototype(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
-pub extern fn JSC__JSGlobalObject__mapIteratorPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.MapIteratorPrototype;
-pub extern fn JSC__JSGlobalObject__mapPrototype(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
-pub extern fn JSC__JSGlobalObject__numberPrototype(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
-pub extern fn JSC__JSGlobalObject__objectPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.ObjectPrototype;
-pub extern fn JSC__JSGlobalObject__promisePrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.JSPromisePrototype;
 pub extern fn JSC__JSGlobalObject__putCachedObject(arg0: ?*JSC__JSGlobalObject, arg1: [*c]const ZigString, JSValue2: JSC__JSValue) JSC__JSValue;
-pub extern fn JSC__JSGlobalObject__regExpPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.RegExpPrototype;
 pub extern fn JSC__JSGlobalObject__reload(arg0: ?*JSC__JSGlobalObject) void;
-pub extern fn JSC__JSGlobalObject__setIteratorPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.SetIteratorPrototype;
 pub extern fn JSC__JSGlobalObject__startRemoteInspector(arg0: ?*JSC__JSGlobalObject, arg1: [*c]u8, arg2: u16) bool;
-pub extern fn JSC__JSGlobalObject__stringPrototype(arg0: ?*JSC__JSGlobalObject) ?*bindings.StringPrototype;
-pub extern fn JSC__JSGlobalObject__symbolPrototype(arg0: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
 pub extern fn JSC__JSGlobalObject__vm(arg0: ?*JSC__JSGlobalObject) [*c]JSC__VM;
-pub extern fn WTF__URL__encodedPassword(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__encodedUser(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__fileSystemPath(arg0: [*c]WTF__URL) bWTF__String;
-pub extern fn WTF__URL__fragmentIdentifier(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__fragmentIdentifierWithLeadingNumberSign(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__fromFileSystemPath(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__fromString(arg0: bWTF__String, arg1: bWTF__String) bWTF__URL;
-pub extern fn WTF__URL__host(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__hostAndPort(arg0: [*c]WTF__URL) bWTF__String;
-pub extern fn WTF__URL__isEmpty(arg0: [*c]const WTF__URL) bool;
-pub extern fn WTF__URL__isValid(arg0: [*c]const WTF__URL) bool;
-pub extern fn WTF__URL__lastPathComponent(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__password(arg0: [*c]WTF__URL) bWTF__String;
-pub extern fn WTF__URL__path(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__protocol(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__protocolHostAndPort(arg0: [*c]WTF__URL) bWTF__String;
-pub extern fn WTF__URL__query(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__queryWithLeadingQuestionMark(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__setHost(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__setHostAndPort(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__setPassword(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__setPath(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__setProtocol(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__setQuery(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__setUser(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
-pub extern fn WTF__URL__stringWithoutFragmentIdentifier(arg0: [*c]WTF__URL) bWTF__String;
-pub extern fn WTF__URL__stringWithoutQueryOrFragmentIdentifier(arg0: [*c]WTF__URL) bWTF__StringView;
-pub extern fn WTF__URL__truncatedForUseAsBase(arg0: [*c]WTF__URL) bWTF__URL;
-pub extern fn WTF__URL__user(arg0: [*c]WTF__URL) bWTF__String;
-pub extern fn WTF__String__characters16(arg0: [*c]WTF__String) [*c]const u16;
-pub extern fn WTF__String__characters8(arg0: [*c]WTF__String) [*c]const u8;
-pub extern fn WTF__String__createFromExternalString(arg0: bWTF__ExternalStringImpl) bWTF__String;
-pub extern fn WTF__String__createWithoutCopyingFromPtr(arg0: [*c]WTF__String, arg1: [*c]const u8, arg2: usize) void;
-pub extern fn WTF__String__eqlSlice(arg0: [*c]WTF__String, arg1: [*c]const u8, arg2: usize) bool;
-pub extern fn WTF__String__eqlString(arg0: [*c]WTF__String, arg1: [*c]const WTF__String) bool;
-pub extern fn WTF__String__impl(arg0: [*c]WTF__String) [*c]const WTF__StringImpl;
-pub extern fn WTF__String__is16Bit(arg0: [*c]WTF__String) bool;
-pub extern fn WTF__String__is8Bit(arg0: [*c]WTF__String) bool;
-pub extern fn WTF__String__isEmpty(arg0: [*c]WTF__String) bool;
-pub extern fn WTF__String__isExternal(arg0: [*c]WTF__String) bool;
-pub extern fn WTF__String__isStatic(arg0: [*c]WTF__String) bool;
-pub extern fn WTF__String__length(arg0: [*c]WTF__String) usize;
 pub extern fn JSC__JSValue___then(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject, JSValue2: JSC__JSValue, ArgFn3: ?fn (?*JSC__JSGlobalObject, ?*bindings.CallFrame) callconv(.C) JSC__JSValue, ArgFn4: ?fn (?*JSC__JSGlobalObject, ?*bindings.CallFrame) callconv(.C) JSC__JSValue) void;
 pub extern fn JSC__JSValue__asArrayBuffer_(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject, arg2: ?*Bun__ArrayBuffer) bool;
 pub extern fn JSC__JSValue__asCell(JSValue0: JSC__JSValue) [*c]JSC__JSCell;
@@ -343,18 +246,11 @@ pub extern fn JSC__JSValue__toError(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGloba
 pub extern fn JSC__JSValue__toInt32(JSValue0: JSC__JSValue) i32;
 pub extern fn JSC__JSValue__toInt64(JSValue0: JSC__JSValue) i64;
 pub extern fn JSC__JSValue__toObject(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject) [*c]JSC__JSObject;
-pub extern fn JSC__JSValue__toPropertyKey(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject) bJSC__Identifier;
-pub extern fn JSC__JSValue__toPropertyKeyValue(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__JSValue__toString(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject) [*c]JSC__JSString;
 pub extern fn JSC__JSValue__toStringOrNull(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject) [*c]JSC__JSString;
 pub extern fn JSC__JSValue__toUInt64NoTruncate(JSValue0: JSC__JSValue) u64;
-pub extern fn JSC__JSValue__toWTFString(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject) bWTF__String;
 pub extern fn JSC__JSValue__toZigException(JSValue0: JSC__JSValue, arg1: ?*JSC__JSGlobalObject, arg2: [*c]ZigException) void;
 pub extern fn JSC__JSValue__toZigString(JSValue0: JSC__JSValue, arg1: [*c]ZigString, arg2: ?*JSC__JSGlobalObject) void;
-pub extern fn JSC__PropertyName__eqlToIdentifier(arg0: [*c]JSC__PropertyName, arg1: [*c]const JSC__Identifier) bool;
-pub extern fn JSC__PropertyName__eqlToPropertyName(arg0: [*c]JSC__PropertyName, arg1: [*c]const JSC__PropertyName) bool;
-pub extern fn JSC__PropertyName__publicName(arg0: [*c]JSC__PropertyName) [*c]const WTF__StringImpl;
-pub extern fn JSC__PropertyName__uid(arg0: [*c]JSC__PropertyName) [*c]const WTF__StringImpl;
 pub extern fn JSC__Exception__create(arg0: ?*JSC__JSGlobalObject, arg1: [*c]JSC__JSObject, StackCaptureAction2: u8) [*c]JSC__Exception;
 pub extern fn JSC__Exception__getStackTrace(arg0: [*c]JSC__Exception, arg1: [*c]ZigStackTrace) void;
 pub extern fn JSC__Exception__value(arg0: [*c]JSC__Exception) JSC__JSValue;
@@ -385,42 +281,6 @@ pub extern fn JSC__ThrowScope__release(arg0: [*c]JSC__ThrowScope) void;
 pub extern fn JSC__CatchScope__clearException(arg0: [*c]JSC__CatchScope) void;
 pub extern fn JSC__CatchScope__declare(arg0: [*c]JSC__VM, arg1: [*c]u8, arg2: [*c]u8, arg3: usize) bJSC__CatchScope;
 pub extern fn JSC__CatchScope__exception(arg0: [*c]JSC__CatchScope) [*c]JSC__Exception;
-pub extern fn JSC__Identifier__deinit(arg0: [*c]const JSC__Identifier) void;
-pub extern fn JSC__Identifier__eqlIdent(arg0: [*c]const JSC__Identifier, arg1: [*c]const JSC__Identifier) bool;
-pub extern fn JSC__Identifier__eqlStringImpl(arg0: [*c]const JSC__Identifier, arg1: [*c]const WTF__StringImpl) bool;
-pub extern fn JSC__Identifier__eqlUTF8(arg0: [*c]const JSC__Identifier, arg1: [*c]const u8, arg2: usize) bool;
-pub extern fn JSC__Identifier__fromSlice(arg0: [*c]JSC__VM, arg1: [*c]const u8, arg2: usize) bJSC__Identifier;
-pub extern fn JSC__Identifier__fromString(arg0: [*c]JSC__VM, arg1: [*c]const WTF__String) bJSC__Identifier;
-pub extern fn JSC__Identifier__isEmpty(arg0: [*c]const JSC__Identifier) bool;
-pub extern fn JSC__Identifier__isNull(arg0: [*c]const JSC__Identifier) bool;
-pub extern fn JSC__Identifier__isPrivateName(arg0: [*c]const JSC__Identifier) bool;
-pub extern fn JSC__Identifier__isSymbol(arg0: [*c]const JSC__Identifier) bool;
-pub extern fn JSC__Identifier__length(arg0: [*c]const JSC__Identifier) usize;
-pub extern fn JSC__Identifier__neqlIdent(arg0: [*c]const JSC__Identifier, arg1: [*c]const JSC__Identifier) bool;
-pub extern fn JSC__Identifier__neqlStringImpl(arg0: [*c]const JSC__Identifier, arg1: [*c]const WTF__StringImpl) bool;
-pub extern fn JSC__Identifier__toString(arg0: [*c]const JSC__Identifier) bWTF__String;
-pub extern fn WTF__StringImpl__characters16(arg0: [*c]const WTF__StringImpl) [*c]const u16;
-pub extern fn WTF__StringImpl__characters8(arg0: [*c]const WTF__StringImpl) [*c]const u8;
-pub extern fn WTF__StringImpl__is16Bit(arg0: [*c]const WTF__StringImpl) bool;
-pub extern fn WTF__StringImpl__is8Bit(arg0: [*c]const WTF__StringImpl) bool;
-pub extern fn WTF__StringImpl__isEmpty(arg0: [*c]const WTF__StringImpl) bool;
-pub extern fn WTF__StringImpl__isExternal(arg0: [*c]const WTF__StringImpl) bool;
-pub extern fn WTF__StringImpl__isStatic(arg0: [*c]const WTF__StringImpl) bool;
-pub extern fn WTF__StringImpl__length(arg0: [*c]const WTF__StringImpl) usize;
-pub extern fn WTF__ExternalStringImpl__characters16(arg0: [*c]const WTF__ExternalStringImpl) [*c]const u16;
-pub extern fn WTF__ExternalStringImpl__characters8(arg0: [*c]const WTF__ExternalStringImpl) [*c]const u8;
-pub extern fn WTF__ExternalStringImpl__create(arg0: [*c]const u8, arg1: usize, ArgFn2: ?fn (?*anyopaque, [*c]u8, usize) callconv(.C) void) bWTF__ExternalStringImpl;
-pub extern fn WTF__ExternalStringImpl__is16Bit(arg0: [*c]const WTF__ExternalStringImpl) bool;
-pub extern fn WTF__ExternalStringImpl__is8Bit(arg0: [*c]const WTF__ExternalStringImpl) bool;
-pub extern fn WTF__ExternalStringImpl__isEmpty(arg0: [*c]const WTF__ExternalStringImpl) bool;
-pub extern fn WTF__ExternalStringImpl__length(arg0: [*c]const WTF__ExternalStringImpl) usize;
-pub extern fn WTF__StringView__characters16(arg0: [*c]const WTF__StringView) [*c]const u16;
-pub extern fn WTF__StringView__characters8(arg0: [*c]const WTF__StringView) [*c]const u8;
-pub extern fn WTF__StringView__from8Bit(arg0: [*c]WTF__StringView, arg1: [*c]const u8, arg2: usize) void;
-pub extern fn WTF__StringView__is16Bit(arg0: [*c]const WTF__StringView) bool;
-pub extern fn WTF__StringView__is8Bit(arg0: [*c]const WTF__StringView) bool;
-pub extern fn WTF__StringView__isEmpty(arg0: [*c]const WTF__StringView) bool;
-pub extern fn WTF__StringView__length(arg0: [*c]const WTF__StringView) usize;
 pub extern fn FFI__ptr__put(arg0: ?*JSC__JSGlobalObject, JSValue1: JSC__JSValue) void;
 pub extern fn Reader__u8__put(arg0: ?*JSC__JSGlobalObject, JSValue1: JSC__JSValue) void;
 pub extern fn Reader__u16__put(arg0: ?*JSC__JSGlobalObject, JSValue1: JSC__JSValue) void;