wip ReadableStream for HTTP(s) Server

42 files changed, 3779 insertions, 1318 deletions

diff --git a/src/bun.js/api/FFI.h b/src/bun.js/api/FFI.h
index e17e15d30..fb8f4710f 100644
--- a/src/bun.js/api/FFI.h
+++ b/src/bun.js/api/FFI.h
@@ -13,6 +13,8 @@
 #define USE_JSVALUE64 1
 #define USE_JSVALUE32_64 0
 
+#define ZIG_REPR_TYPE uint64_t
+
 
 // /* 7.18.1.1  Exact-width integer types */
 typedef unsigned char uint8_t;
@@ -80,6 +82,8 @@ typedef union EncodedJSValue {
 
   void* asPtr;
   double asDouble;
+
+  ZIG_REPR_TYPE asZigRepr;
 } EncodedJSValue;
 
 EncodedJSValue ValueUndefined = { TagValueUndefined };
@@ -244,7 +248,7 @@ static EncodedJSValue INT64_TO_JSVALUE(void* globalObject, int64_t val) {
 }
 
 #ifndef IS_CALLBACK
-void* JSFunctionCall(void* globalObject, void* callFrame);
+ZIG_REPR_TYPE JSFunctionCall(void* globalObject, void* callFrame);
 
 #endif
 
diff --git a/src/bun.js/api/html_rewriter.zig b/src/bun.js/api/html_rewriter.zig
index fc91c76ad..3ba5cb6c6 100644
--- a/src/bun.js/api/html_rewriter.zig
+++ b/src/bun.js/api/html_rewriter.zig
@@ -734,7 +734,7 @@ const DocumentHandler = struct {
             else => |kind| {
                 JSC.throwInvalidArguments(
                     "Expected object but received {s}",
-                    .{std.mem.span(@tagName(kind))},
+                    .{@as(string, @tagName(kind))},
                     global.ref(),
                     exception,
                 );
@@ -885,7 +885,7 @@ const ElementHandler = struct {
             else => |kind| {
                 JSC.throwInvalidArguments(
                     "Expected object but received {s}",
-                    .{std.mem.span(@tagName(kind))},
+                    .{@as(string, @tagName(kind))},
                     global.ref(),
                     exception,
                 );
diff --git a/src/bun.js/api/router.zig b/src/bun.js/api/router.zig
index 847e7a756..318514d34 100644
--- a/src/bun.js/api/router.zig
+++ b/src/bun.js/api/router.zig
@@ -30,6 +30,7 @@ const d = Base.d;
 const FetchEvent = WebCore.FetchEvent;
 const URLPath = @import("../../http/url_path.zig");
 const URL = @import("../../url.zig").URL;
+
 route: *const FilesystemRouter.Match,
 route_holder: FilesystemRouter.Match = undefined,
 needs_deinit: bool = false,
diff --git a/src/bun.js/api/server.zig b/src/bun.js/api/server.zig
index cb3c4387a..35abc0a7f 100644
--- a/src/bun.js/api/server.zig
+++ b/src/bun.js/api/server.zig
@@ -503,7 +503,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
         const App = uws.NewApp(ssl_enabled);
         pub threadlocal var pool: ?*RequestContext.RequestContextStackAllocator = null;
         pub threadlocal var pool_allocator: std.mem.Allocator = undefined;
-
+        pub const ResponseStream = JSC.WebCore.HTTPServerWritable(ssl_enabled);
         pub const RequestContextStackAllocator = NewRequestContextStackAllocator(RequestContext, 2048);
         pub const name = "HTTPRequestContext" ++ (if (debug_mode) "Debug" else "") ++ (if (ThisServer.ssl_enabled) "TLS" else "");
         pub const shim = JSC.Shimmer("Bun", name, @This());
@@ -537,6 +537,8 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
         request_js_object: JSC.C.JSObjectRef = null,
         request_body_buf: std.ArrayListUnmanaged(u8) = .{},
 
+        has_written_status: bool = false,
+
         /// Used either for temporary blob data or fallback
         /// When the response body is a temporary value
         response_buf_owned: std.ArrayListUnmanaged(u8) = .{},
@@ -628,11 +630,15 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
 
         pub fn renderMissing(ctx: *RequestContext) void {
             if (comptime !debug_mode) {
-                ctx.resp.writeStatus("204 No Content");
+                if (!ctx.has_written_status)
+                    ctx.resp.writeStatus("204 No Content");
+                ctx.has_written_status = true;
                 ctx.resp.endWithoutBody();
                 ctx.finalize();
             } else {
-                ctx.resp.writeStatus("200 OK");
+                if (!ctx.has_written_status)
+                    ctx.resp.writeStatus("200 OK");
+                ctx.has_written_status = true;
                 ctx.resp.end("Welcome to Bun! To get started, return a Response object.", false);
                 ctx.finalize();
             }
@@ -646,8 +652,12 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             comptime fmt: string,
             args: anytype,
         ) void {
-            this.resp.writeStatus("500 Internal Server Error");
-            this.resp.writeHeader("content-type", MimeType.html.value);
+            if (!this.has_written_status) {
+                this.has_written_status = true;
+
+                this.resp.writeStatus("500 Internal Server Error");
+                this.resp.writeHeader("content-type", MimeType.html.value);
+            }
 
             const allocator = this.allocator;
 
@@ -1122,6 +1132,21 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             doRenderWithBody(bun.cast(*RequestContext, this), value);
         }
 
+        fn renderWithBlobFromBodyValue(this: *RequestContext) void {
+            if (this.aborted) {
+                this.finalizeForAbort();
+                return;
+            }
+
+            if (this.blob.needsToReadFile()) {
+                this.req.setYield(false);
+                if (!this.has_sendfile_ctx)
+                    this.doSendfile(this.blob);
+                return;
+            }
+
+            this.doRenderBlob();
+        }
         pub fn doRenderWithBody(this: *RequestContext, value: *JSC.WebCore.Body.Value) void {
             switch (value.*) {
                 .Error => {
@@ -1136,23 +1161,216 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
                 },
                 .Blob => {
                     this.blob = value.use();
-
+                    this.renderWithBlobFromBodyValue();
+                    return;
+                },
+                .Locked => |*lock| {
                     if (this.aborted) {
                         this.finalizeForAbort();
                         return;
                     }
 
-                    if (this.blob.needsToReadFile()) {
-                        this.req.setYield(false);
-                        if (!this.has_sendfile_ctx)
-                            this.doSendfile(this.blob);
-                        return;
-                    }
-                },
-                // TODO: this needs to support streaming!
-                .Locked => |*lock| {
                     lock.callback = doRenderWithBodyLocked;
                     lock.task = this;
+                    if (lock.readable) |stream_| {
+                        const stream: JSC.WebCore.ReadableStream = stream_;
+                        stream.value.ensureStillAlive();
+                        value.* = .{ .Used = {} };
+
+                        if (stream.isLocked(this.server.globalThis)) {
+                            Output.debug("response_stream was locked but it shouldn't be", .{});
+                            var err = JSC.SystemError{
+                                .code = ZigString.init(@as(string, @tagName(JSC.Node.ErrorCode.ERR_STREAM_CANNOT_PIPE))),
+                                .message = ZigString.init("Stream already used, please create a new one"),
+                            };
+
+                            this.runErrorHandler(err.toErrorInstance(this.server.globalThis));
+                            return;
+                        }
+
+                        switch (stream.ptr) {
+                            .Invalid => {},
+
+                            // fast path for Blob
+                            .Blob => |val| {
+                                Output.debug("response_stream was Blob", .{});
+                                this.blob = JSC.WebCore.Blob.initWithStore(val.store, this.server.globalThis);
+                                this.blob.offset = val.offset;
+                                this.blob.size = val.remain;
+
+                                val.store.ref();
+                                stream.detach(this.server.globalThis);
+                                val.deinit();
+                                this.renderWithBlobFromBodyValue();
+                                return;
+                            },
+
+                            // fast path for File
+                            .File => |val| {
+                                Output.debug("response_stream was File Blob", .{});
+                                this.blob = JSC.WebCore.Blob.initWithStore(val.store, this.server.globalThis);
+                                val.store.ref();
+
+                                // it should be lazy, file shouldn't have opened yet.
+                                std.debug.assert(!val.started);
+
+                                stream.detach(this.server.globalThis);
+                                val.deinit();
+                                this.renderWithBlobFromBodyValue();
+                                return;
+                            },
+
+                            .JavaScript, .Direct => {
+                                if (this.has_abort_handler)
+                                    this.resp.runCorked(*RequestContext, renderMetadata, this)
+                                else
+                                    this.renderMetadata();
+
+                                stream.value.ensureStillAlive();
+                                var response_stream = this.allocator.create(ResponseStream.JSSink) catch unreachable;
+                                response_stream.* = ResponseStream.JSSink{
+                                    .sink = .{
+                                        .res = this.resp,
+                                        .allocator = this.allocator,
+                                        .buffer = bun.ByteList.init(""),
+                                    },
+                                };
+                                var signal = &response_stream.sink.signal;
+                                signal.* = ResponseStream.JSSink.SinkSignal.init(JSValue.zero);
+
+                                // explicitly set it to a dead pointer
+                                // we use this memory address to disable signals being sent
+                                signal.clear();
+                                std.debug.assert(signal.isDead());
+
+                                const assignment_result: JSValue = ResponseStream.JSSink.assignToStream(
+                                    this.server.globalThis,
+                                    stream.value,
+                                    response_stream,
+                                    @ptrCast(**anyopaque, &signal.ptr),
+                                );
+
+                                // assert that it was updated
+                                std.debug.assert(!signal.isDead());
+
+                                if (comptime Environment.allow_assert) {
+                                    if (this.resp.hasResponded()) {
+                                        Output.debug("response_stream responded", .{});
+                                    }
+                                }
+
+                                this.aborted = this.aborted or response_stream.sink.aborted;
+
+                                if (assignment_result.isAnyError(this.server.globalThis)) {
+                                    Output.debug("response_stream returned an error", .{});
+                                    response_stream.detach();
+                                    this.allocator.destroy(response_stream);
+                                    return this.handleReject(assignment_result);
+                                }
+
+                                if (response_stream.sink.done or
+                                    // TODO: is there a condition where resp could be freed before done?
+                                    this.resp.hasResponded())
+                                {
+                                    Output.debug("response_stream is done", .{});
+                                    response_stream.detach();
+                                    this.allocator.destroy(response_stream);
+
+                                    if (!this.resp.hasResponded()) {
+                                        this.renderMissing();
+                                        return;
+                                    }
+
+                                    this.finalize();
+                                    return;
+                                }
+
+                                // it returns a Promise when it goes through ReadableStreamDefaultReader
+                                if (assignment_result.asPromise()) |promise| {
+                                    Output.debug("response_stream returned a promise", .{});
+                                    switch (promise.status(this.server.globalThis.vm())) {
+                                        .Pending => {
+                                            // TODO: should this timeout?
+                                            this.resp.onAborted(*ResponseStream, ResponseStream.onAborted, &response_stream.sink);
+                                            const AwaitPromise = struct {
+                                                pub fn onResolve(req: *RequestContext, _: *JSGlobalObject, _: []const JSC.JSValue) void {
+                                                    Output.debug("response_stream promise resolved", .{});
+                                                    if (!req.resp.hasResponded()) {
+                                                        req.renderMissing();
+                                                        return;
+                                                    }
+                                                    req.finalize();
+                                                }
+                                                pub fn onReject(req: *RequestContext, globalThis: *JSGlobalObject, args: []const JSC.JSValue) void {
+                                                    Output.debug("response_stream promise rejected", .{});
+                                                    if (args.len > 0) {
+                                                        req.handleReject(args[0]);
+                                                        return;
+                                                    }
+
+                                                    const fallback = JSC.SystemError{
+                                                        .code = ZigString.init(@as(string, @tagName(JSC.Node.ErrorCode.ERR_UNHANDLED_ERROR))),
+                                                        .message = ZigString.init("Unhandled error in ReadableStream"),
+                                                    };
+                                                    req.handleReject(fallback.toErrorInstance(globalThis));
+                                                }
+                                            };
+                                            assignment_result.then(
+                                                this.server.globalThis,
+                                                RequestContext,
+                                                this,
+                                                AwaitPromise.onResolve,
+                                                AwaitPromise.onReject,
+                                            );
+                                            // the response_stream should be GC'd
+                                            return;
+                                        },
+                                        .Fulfilled => {
+                                            this.aborted = this.aborted or response_stream.sink.aborted;
+                                            response_stream.detach();
+
+                                            this.allocator.destroy(response_stream);
+
+                                            _ = promise.result(this.server.globalThis.vm());
+                                            if (!this.resp.hasResponded()) {
+                                                this.renderMissing();
+                                                return;
+                                            }
+                                            this.finalize();
+                                            return;
+                                        },
+                                        .Rejected => {
+                                            this.aborted = this.aborted or response_stream.sink.aborted;
+                                            response_stream.detach();
+                                            this.allocator.destroy(response_stream);
+
+                                            this.handleReject(promise.result(this.server.globalThis.vm()));
+                                            return;
+                                        },
+                                    }
+                                    return;
+                                }
+
+                                if (this.aborted) {
+                                    this.finalizeForAbort();
+                                    return;
+                                }
+
+                                stream.value.ensureStillAlive();
+
+                                if (!stream.isLocked(this.server.globalThis)) {
+                                    Output.debug("response_stream is not locked", .{});
+                                    this.renderMissing();
+                                    return;
+                                }
+
+                                this.resp.onAborted(*ResponseStream, ResponseStream.onAborted, &response_stream.sink);
+                                Output.debug("response_stream is in progress, but did not return a Promise. Finalizing request context", .{});
+                                this.finalize();
+                                return;
+                            },
+                        }
+                    }
                     return;
                 },
                 else => {},
@@ -1182,12 +1400,20 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
         pub fn renderProductionError(this: *RequestContext, status: u16) void {
             switch (status) {
                 404 => {
-                    this.resp.writeStatus("404 Not Found");
+                    if (!this.has_written_status) {
+                        this.resp.writeStatus("404 Not Found");
+                        this.has_written_status = true;
+                    }
+
                     this.resp.endWithoutBody();
                 },
                 else => {
-                    this.resp.writeStatus("500 Internal Server Error");
-                    this.resp.writeHeader("content-type", "text/plain");
+                    if (!this.has_written_status) {
+                        this.resp.writeStatus("500 Internal Server Error");
+                        this.resp.writeHeader("content-type", "text/plain");
+                        this.has_written_status = true;
+                    }
+
                     this.resp.end("Something went wrong!", true);
                 },
             }
@@ -1236,7 +1462,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
                     error.ExceptionOcurred,
                     exception_list.toOwnedSlice(),
                     "<r><red>{s}<r> - <b>{s}<r> failed",
-                    .{ std.mem.span(@tagName(this.method)), this.url },
+                    .{ @as(string, @tagName(this.method)), this.url },
                 );
             } else {
                 if (status != 404)
@@ -1251,11 +1477,14 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             var response: *JSC.WebCore.Response = this.response_ptr.?;
             var status = response.statusCode();
             const size = this.blob.size;
-            status = if (status == 200 and size == 0)
+            status = if (status == 200 and size == 0 and !this.blob.isDetached())
                 204
             else
                 status;
 
+            std.debug.assert(!this.has_written_status);
+            this.has_written_status = true;
+
             this.writeStatus(status);
             var needs_content_type = true;
             const content_type: MimeType = brk: {
@@ -1284,7 +1513,11 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
                 headers_.deref();
             }
 
-            if (needs_content_type) {
+            if (needs_content_type and
+                // do not insert the content type if it is the fallback value
+                // we may not know the content-type when streaming
+                (!this.blob.isDetached() or content_type.value.ptr != MimeType.other.value.ptr))
+            {
                 this.resp.writeHeader("content-type", content_type.value);
             }
 
diff --git a/src/bun.js/bindings/FFI.zig b/src/bun.js/bindings/FFI.zig
index 433772f81..0fc33d303 100644
--- a/src/bun.js/bindings/FFI.zig
+++ b/src/bun.js/bindings/FFI.zig
@@ -59,8 +59,8 @@ pub inline fn JSVALUE_TO_INT64(arg_value: EncodedJSValue) i64 {
 }
 pub extern fn JSVALUE_TO_UINT64_SLOW(globalObject: ?*anyopaque, value: EncodedJSValue) u64;
 pub extern fn JSVALUE_TO_INT64_SLOW(value: EncodedJSValue) i64;
-pub extern fn UINT64_TO_JSVALUE_SLOW(globalObject: ?*anyopaque, val: u64) EncodedJSValue;
-pub extern fn INT64_TO_JSVALUE_SLOW(globalObject: ?*anyopaque, val: i64) EncodedJSValue;
+pub const UINT64_TO_JSVALUE_SLOW = @import("./bindings.zig").JSValue.fromUInt64NoTruncate;
+pub const INT64_TO_JSVALUE_SLOW = @import("./bindings.zig").JSValue.fromInt64NoTruncate;
 pub inline fn UINT64_TO_JSVALUE(arg_globalObject: ?*anyopaque, arg_val: u64) EncodedJSValue {
     var globalObject = arg_globalObject;
     const val = arg_val;
@@ -70,7 +70,7 @@ pub inline fn UINT64_TO_JSVALUE(arg_globalObject: ?*anyopaque, arg_val: u64) Enc
     if (val < @bitCast(c_ulonglong, @as(c_longlong, @as(c_long, 9007199254740991)))) {
         return DOUBLE_TO_JSVALUE(@intToFloat(f64, val));
     }
-    return UINT64_TO_JSVALUE_SLOW(globalObject, val);
+    return UINT64_TO_JSVALUE_SLOW(@ptrCast(*@import("./bindings.zig").JSGlobalObject, globalObject.?), val).asEncoded();
 }
 pub inline fn INT64_TO_JSVALUE(arg_globalObject: ?*anyopaque, arg_val: i64) EncodedJSValue {
     var globalObject = arg_globalObject;
@@ -81,7 +81,7 @@ pub inline fn INT64_TO_JSVALUE(arg_globalObject: ?*anyopaque, arg_val: i64) Enco
     if ((val >= @bitCast(c_longlong, @as(c_longlong, -@as(c_long, 9007199254740991)))) and (val <= @bitCast(c_longlong, @as(c_longlong, @as(c_long, 9007199254740991))))) {
         return DOUBLE_TO_JSVALUE(@intToFloat(f64, val));
     }
-    return INT64_TO_JSVALUE_SLOW(globalObject, val);
+    return INT64_TO_JSVALUE_SLOW(@ptrCast(*@import("./bindings.zig").JSGlobalObject, globalObject.?), val).asEncoded();
 }
 pub inline fn INT32_TO_JSVALUE(arg_val: i32) EncodedJSValue {
     return .{ .asInt64 = @bitCast(i64, @as(c_ulonglong, 18446181123756130304) | @bitCast(c_ulonglong, @as(c_ulonglong, @bitCast(u32, arg_val)))) };
diff --git a/src/bun.js/bindings/JSSink.cpp b/src/bun.js/bindings/JSSink.cpp
index 3c0d03174..22423127a 100644
--- a/src/bun.js/bindings/JSSink.cpp
+++ b/src/bun.js/bindings/JSSink.cpp
@@ -1,6 +1,6 @@
 
 // AUTO-GENERATED FILE. DO NOT EDIT.
-// Generated by /Users/jarred/Code/bun/src/bun.js/generate-jssink.js at 2022-06-15T10:28:21.211Z
+// Generated by /Users/jarred/Code/bun/src/bun.js/generate-jssink.js at 2022-06-26T11:24:51.211Z
 // To regenerate this file, run:
 //
 //  bun src/bun.js/generate-jssink.js
@@ -85,13 +85,31 @@ JSC_DEFINE_HOST_FUNCTION(functionStartDirectStream, (JSC::JSGlobalObject * lexic
 
     if (WebCore::JSReadableArrayBufferSinkController* ArrayBufferSinkController = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(callFrame->thisValue())) {
         if (ArrayBufferSinkController->wrapped() == nullptr) {
-            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Controller is already closed"_s));
+            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
             return JSC::JSValue::encode(JSC::jsUndefined());
         }
 
         ArrayBufferSinkController->start(globalObject, readableStream, onPullFunction, onCloseFunction);
     }
 
+    else if (WebCore::JSReadableHTTPResponseSinkController* HTTPResponseSinkController = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(callFrame->thisValue())) {
+        if (HTTPResponseSinkController->wrapped() == nullptr) {
+            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
+            return JSC::JSValue::encode(JSC::jsUndefined());
+        }
+
+        HTTPResponseSinkController->start(globalObject, readableStream, onPullFunction, onCloseFunction);
+    }
+
+    else if (WebCore::JSReadableHTTPSResponseSinkController* HTTPSResponseSinkController = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(callFrame->thisValue())) {
+        if (HTTPSResponseSinkController->wrapped() == nullptr) {
+            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
+            return JSC::JSValue::encode(JSC::jsUndefined());
+        }
+
+        HTTPSResponseSinkController->start(globalObject, readableStream, onPullFunction, onCloseFunction);
+    }
+
     else {
         scope.throwException(globalObject, JSC::createTypeError(globalObject, "Unknown direct controller. This is a bug in Bun."_s));
         return JSC::JSValue::encode(JSC::jsUndefined());
@@ -123,7 +141,6 @@ JSC_DEFINE_HOST_FUNCTION(JSReadableArrayBufferSinkController__close, (JSC::JSGlo
 
     void* ptr = controller->wrapped();
     if (ptr == nullptr) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Controller is already closed"_s));
         return JSC::JSValue::encode(JSC::jsUndefined());
     }
 
@@ -132,6 +149,28 @@ JSC_DEFINE_HOST_FUNCTION(JSReadableArrayBufferSinkController__close, (JSC::JSGlo
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
+JSC_DECLARE_HOST_FUNCTION(JSReadableArrayBufferSinkController__end);
+JSC_DEFINE_HOST_FUNCTION(JSReadableArrayBufferSinkController__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::JSReadableArrayBufferSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(callFrame->thisValue());
+    if (!controller) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableArrayBufferSinkController"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void* ptr = controller->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    controller->detach();
+    return ArrayBufferSink__endWithSink(ptr, lexicalGlobalObject);
+}
+
 JSC_DECLARE_HOST_FUNCTION(ArrayBufferSink__doClose);
 JSC_DEFINE_HOST_FUNCTION(ArrayBufferSink__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
 {
@@ -147,7 +186,6 @@ JSC_DEFINE_HOST_FUNCTION(ArrayBufferSink__doClose, (JSC::JSGlobalObject * lexica
 
     void* ptr = sink->wrapped();
     if (ptr == nullptr) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Controller is already closed"_s));
         return JSC::JSValue::encode(JSC::jsUndefined());
     }
 
@@ -169,11 +207,199 @@ static const HashTableValue JSReadableArrayBufferSinkControllerPrototypeTableVal
     = {
           { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(JSReadableArrayBufferSinkController__close), (intptr_t)(0) } },
           { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(ArrayBufferSink__drain), (intptr_t)(1) } },
-          { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(ArrayBufferSink__end), (intptr_t)(0) } },
+          { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(JSReadableArrayBufferSinkController__end), (intptr_t)(0) } },
           { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(ArrayBufferSink__start), (intptr_t)(1) } },
           { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(ArrayBufferSink__write), (intptr_t)(1) } },
       };
 
+JSC_DEFINE_CUSTOM_GETTER(functionHTTPResponseSink__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+
+    return JSC::JSValue::encode(globalObject->HTTPResponseSink());
+}
+
+JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__close);
+JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__close, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(callFrame->thisValue());
+    if (!controller) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPResponseSinkController"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void* ptr = controller->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    controller->detach();
+    HTTPResponseSink__close(lexicalGlobalObject, ptr);
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__end);
+JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(callFrame->thisValue());
+    if (!controller) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPResponseSinkController"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void* ptr = controller->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    controller->detach();
+    return HTTPResponseSink__endWithSink(ptr, lexicalGlobalObject);
+}
+
+JSC_DECLARE_HOST_FUNCTION(HTTPResponseSink__doClose);
+JSC_DEFINE_HOST_FUNCTION(HTTPResponseSink__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::JSHTTPResponseSink* sink = JSC::jsDynamicCast<WebCore::JSHTTPResponseSink*>(callFrame->thisValue());
+    if (!sink) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected HTTPResponseSink"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void* ptr = sink->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    sink->detach();
+    HTTPResponseSink__close(lexicalGlobalObject, ptr);
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+static const HashTableValue JSHTTPResponseSinkPrototypeTableValues[]
+    = {
+          { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__doClose), (intptr_t)(0) } },
+          { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__drain), (intptr_t)(1) } },
+          { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__end), (intptr_t)(0) } },
+          { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__start), (intptr_t)(1) } },
+          { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__write), (intptr_t)(1) } },
+      };
+
+static const HashTableValue JSReadableHTTPResponseSinkControllerPrototypeTableValues[]
+    = {
+          { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(JSReadableHTTPResponseSinkController__close), (intptr_t)(0) } },
+          { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__drain), (intptr_t)(1) } },
+          { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(JSReadableHTTPResponseSinkController__end), (intptr_t)(0) } },
+          { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__start), (intptr_t)(1) } },
+          { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPResponseSink__write), (intptr_t)(1) } },
+      };
+
+JSC_DEFINE_CUSTOM_GETTER(functionHTTPSResponseSink__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+
+    return JSC::JSValue::encode(globalObject->HTTPSResponseSink());
+}
+
+JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__close);
+JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__close, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(callFrame->thisValue());
+    if (!controller) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPSResponseSinkController"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void* ptr = controller->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    controller->detach();
+    HTTPSResponseSink__close(lexicalGlobalObject, ptr);
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__end);
+JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(callFrame->thisValue());
+    if (!controller) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPSResponseSinkController"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void* ptr = controller->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    controller->detach();
+    return HTTPSResponseSink__endWithSink(ptr, lexicalGlobalObject);
+}
+
+JSC_DECLARE_HOST_FUNCTION(HTTPSResponseSink__doClose);
+JSC_DEFINE_HOST_FUNCTION(HTTPSResponseSink__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
+{
+
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::JSHTTPSResponseSink* sink = JSC::jsDynamicCast<WebCore::JSHTTPSResponseSink*>(callFrame->thisValue());
+    if (!sink) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected HTTPSResponseSink"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void* ptr = sink->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    sink->detach();
+    HTTPSResponseSink__close(lexicalGlobalObject, ptr);
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+static const HashTableValue JSHTTPSResponseSinkPrototypeTableValues[]
+    = {
+          { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__doClose), (intptr_t)(0) } },
+          { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__drain), (intptr_t)(1) } },
+          { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__end), (intptr_t)(0) } },
+          { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__start), (intptr_t)(1) } },
+          { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__write), (intptr_t)(1) } },
+      };
+
+static const HashTableValue JSReadableHTTPSResponseSinkControllerPrototypeTableValues[]
+    = {
+          { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(JSReadableHTTPSResponseSinkController__close), (intptr_t)(0) } },
+          { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__drain), (intptr_t)(1) } },
+          { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(JSReadableHTTPSResponseSinkController__end), (intptr_t)(0) } },
+          { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__start), (intptr_t)(1) } },
+          { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(HTTPSResponseSink__write), (intptr_t)(1) } },
+      };
+
 #pragma mark - ArrayBufferSink
 
 class JSArrayBufferSinkPrototype final : public JSC::JSNonFinalObject {
@@ -380,6 +606,418 @@ void JSReadableArrayBufferSinkController::destroy(JSCell* cell)
     static_cast<JSReadableArrayBufferSinkController*>(cell)->JSReadableArrayBufferSinkController::~JSReadableArrayBufferSinkController();
 }
 
+#pragma mark - HTTPResponseSink
+
+class JSHTTPResponseSinkPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+
+    static JSHTTPResponseSinkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSHTTPResponseSinkPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPResponseSinkPrototype>(vm)) JSHTTPResponseSinkPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm, globalObject);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSHTTPResponseSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+        : Base(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPResponseSinkPrototype, JSHTTPResponseSinkPrototype::Base);
+
+class JSReadableHTTPResponseSinkControllerPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+
+    static JSReadableHTTPResponseSinkControllerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSReadableHTTPResponseSinkControllerPrototype* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPResponseSinkControllerPrototype>(vm)) JSReadableHTTPResponseSinkControllerPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm, globalObject);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSReadableHTTPResponseSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+        : Base(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableHTTPResponseSinkControllerPrototype, JSReadableHTTPResponseSinkControllerPrototype::Base);
+
+const ClassInfo JSHTTPResponseSinkPrototype::s_info = { "HTTPResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPResponseSinkPrototype) };
+const ClassInfo JSHTTPResponseSink::s_info = { "HTTPResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPResponseSink) };
+const ClassInfo JSHTTPResponseSinkConstructor::s_info = { "HTTPResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPResponseSinkConstructor) };
+
+const ClassInfo JSReadableHTTPResponseSinkControllerPrototype::s_info = { "ReadableHTTPResponseSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPResponseSinkControllerPrototype) };
+const ClassInfo JSReadableHTTPResponseSinkController::s_info = { "ReadableHTTPResponseSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPResponseSinkController) };
+
+JSHTTPResponseSink::~JSHTTPResponseSink()
+{
+    if (m_sinkPtr) {
+        HTTPResponseSink__finalize(m_sinkPtr);
+    }
+}
+
+JSReadableHTTPResponseSinkController::~JSReadableHTTPResponseSinkController()
+{
+    if (m_sinkPtr) {
+        HTTPResponseSink__finalize(m_sinkPtr);
+    }
+}
+
+JSHTTPResponseSinkConstructor* JSHTTPResponseSinkConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
+{
+    JSHTTPResponseSinkConstructor* ptr = new (NotNull, JSC::allocateCell<JSHTTPResponseSinkConstructor>(vm)) JSHTTPResponseSinkConstructor(vm, structure, HTTPResponseSink__construct);
+    ptr->finishCreation(vm, globalObject, prototype);
+    return ptr;
+}
+
+JSHTTPResponseSink* JSHTTPResponseSink::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
+{
+    JSHTTPResponseSink* ptr = new (NotNull, JSC::allocateCell<JSHTTPResponseSink>(vm)) JSHTTPResponseSink(vm, structure, sinkPtr);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+JSReadableHTTPResponseSinkController* JSReadableHTTPResponseSinkController::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
+{
+    JSReadableHTTPResponseSinkController* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPResponseSinkController>(vm)) JSReadableHTTPResponseSinkController(vm, structure, sinkPtr);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+void JSHTTPResponseSinkConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+    initializeProperties(vm, globalObject, prototype);
+}
+
+JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSHTTPResponseSinkConstructor::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame)
+{
+    return HTTPResponseSink__construct(globalObject, callFrame);
+}
+
+void JSHTTPResponseSinkConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
+{
+    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    JSString* nameString = jsNontrivialString(vm, "HTTPResponseSink"_s);
+    m_originalName.set(vm, this, nameString);
+    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+}
+
+void JSHTTPResponseSinkPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSHTTPResponseSink::info(), JSHTTPResponseSinkPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void JSReadableHTTPResponseSinkControllerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSReadableHTTPResponseSinkController::info(), JSReadableHTTPResponseSinkControllerPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void JSHTTPResponseSink::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+void JSReadableHTTPResponseSinkController::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+void JSHTTPResponseSink::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSHTTPResponseSink*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        analyzer.setWrappedObjectForCell(cell, wrapped);
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+void JSReadableHTTPResponseSinkController::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSReadableHTTPResponseSinkController*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        analyzer.setWrappedObjectForCell(cell, wrapped);
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+template<typename Visitor>
+void JSReadableHTTPResponseSinkController::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    JSReadableHTTPResponseSinkController* thisObject = jsCast<JSReadableHTTPResponseSinkController*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    visitor.append(thisObject->m_onPull);
+    visitor.append(thisObject->m_onClose);
+    visitor.append(thisObject->m_weakReadableStream);
+}
+
+DEFINE_VISIT_CHILDREN(JSReadableHTTPResponseSinkController);
+
+void JSReadableHTTPResponseSinkController::start(JSC::JSGlobalObject* globalObject, JSC::JSValue readableStream, JSC::JSFunction* onPull, JSC::JSFunction* onClose)
+{
+    this->m_weakReadableStream = JSC::Weak<JSC::JSObject>(readableStream.getObject());
+    this->m_onPull.set(globalObject->vm(), this, onPull);
+    this->m_onClose.set(globalObject->vm(), this, onClose);
+}
+
+void JSHTTPResponseSink::destroy(JSCell* cell)
+{
+    static_cast<JSHTTPResponseSink*>(cell)->JSHTTPResponseSink::~JSHTTPResponseSink();
+}
+
+void JSReadableHTTPResponseSinkController::destroy(JSCell* cell)
+{
+    static_cast<JSReadableHTTPResponseSinkController*>(cell)->JSReadableHTTPResponseSinkController::~JSReadableHTTPResponseSinkController();
+}
+
+#pragma mark - HTTPSResponseSink
+
+class JSHTTPSResponseSinkPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+
+    static JSHTTPSResponseSinkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSHTTPSResponseSinkPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPSResponseSinkPrototype>(vm)) JSHTTPSResponseSinkPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm, globalObject);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSHTTPSResponseSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+        : Base(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPSResponseSinkPrototype, JSHTTPSResponseSinkPrototype::Base);
+
+class JSReadableHTTPSResponseSinkControllerPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+
+    static JSReadableHTTPSResponseSinkControllerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSReadableHTTPSResponseSinkControllerPrototype* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPSResponseSinkControllerPrototype>(vm)) JSReadableHTTPSResponseSinkControllerPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm, globalObject);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSReadableHTTPSResponseSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+        : Base(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableHTTPSResponseSinkControllerPrototype, JSReadableHTTPSResponseSinkControllerPrototype::Base);
+
+const ClassInfo JSHTTPSResponseSinkPrototype::s_info = { "HTTPSResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPSResponseSinkPrototype) };
+const ClassInfo JSHTTPSResponseSink::s_info = { "HTTPSResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPSResponseSink) };
+const ClassInfo JSHTTPSResponseSinkConstructor::s_info = { "HTTPSResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPSResponseSinkConstructor) };
+
+const ClassInfo JSReadableHTTPSResponseSinkControllerPrototype::s_info = { "ReadableHTTPSResponseSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPSResponseSinkControllerPrototype) };
+const ClassInfo JSReadableHTTPSResponseSinkController::s_info = { "ReadableHTTPSResponseSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPSResponseSinkController) };
+
+JSHTTPSResponseSink::~JSHTTPSResponseSink()
+{
+    if (m_sinkPtr) {
+        HTTPSResponseSink__finalize(m_sinkPtr);
+    }
+}
+
+JSReadableHTTPSResponseSinkController::~JSReadableHTTPSResponseSinkController()
+{
+    if (m_sinkPtr) {
+        HTTPSResponseSink__finalize(m_sinkPtr);
+    }
+}
+
+JSHTTPSResponseSinkConstructor* JSHTTPSResponseSinkConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
+{
+    JSHTTPSResponseSinkConstructor* ptr = new (NotNull, JSC::allocateCell<JSHTTPSResponseSinkConstructor>(vm)) JSHTTPSResponseSinkConstructor(vm, structure, HTTPSResponseSink__construct);
+    ptr->finishCreation(vm, globalObject, prototype);
+    return ptr;
+}
+
+JSHTTPSResponseSink* JSHTTPSResponseSink::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
+{
+    JSHTTPSResponseSink* ptr = new (NotNull, JSC::allocateCell<JSHTTPSResponseSink>(vm)) JSHTTPSResponseSink(vm, structure, sinkPtr);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+JSReadableHTTPSResponseSinkController* JSReadableHTTPSResponseSinkController::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
+{
+    JSReadableHTTPSResponseSinkController* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPSResponseSinkController>(vm)) JSReadableHTTPSResponseSinkController(vm, structure, sinkPtr);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+void JSHTTPSResponseSinkConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+    initializeProperties(vm, globalObject, prototype);
+}
+
+JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSHTTPSResponseSinkConstructor::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame)
+{
+    return HTTPSResponseSink__construct(globalObject, callFrame);
+}
+
+void JSHTTPSResponseSinkConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
+{
+    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    JSString* nameString = jsNontrivialString(vm, "HTTPSResponseSink"_s);
+    m_originalName.set(vm, this, nameString);
+    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+}
+
+void JSHTTPSResponseSinkPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSHTTPSResponseSink::info(), JSHTTPSResponseSinkPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void JSReadableHTTPSResponseSinkControllerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSReadableHTTPSResponseSinkController::info(), JSReadableHTTPSResponseSinkControllerPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void JSHTTPSResponseSink::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+void JSReadableHTTPSResponseSinkController::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+void JSHTTPSResponseSink::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSHTTPSResponseSink*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        analyzer.setWrappedObjectForCell(cell, wrapped);
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+void JSReadableHTTPSResponseSinkController::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSReadableHTTPSResponseSinkController*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        analyzer.setWrappedObjectForCell(cell, wrapped);
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+template<typename Visitor>
+void JSReadableHTTPSResponseSinkController::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    JSReadableHTTPSResponseSinkController* thisObject = jsCast<JSReadableHTTPSResponseSinkController*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    visitor.append(thisObject->m_onPull);
+    visitor.append(thisObject->m_onClose);
+    visitor.append(thisObject->m_weakReadableStream);
+}
+
+DEFINE_VISIT_CHILDREN(JSReadableHTTPSResponseSinkController);
+
+void JSReadableHTTPSResponseSinkController::start(JSC::JSGlobalObject* globalObject, JSC::JSValue readableStream, JSC::JSFunction* onPull, JSC::JSFunction* onClose)
+{
+    this->m_weakReadableStream = JSC::Weak<JSC::JSObject>(readableStream.getObject());
+    this->m_onPull.set(globalObject->vm(), this, onPull);
+    this->m_onClose.set(globalObject->vm(), this, onClose);
+}
+
+void JSHTTPSResponseSink::destroy(JSCell* cell)
+{
+    static_cast<JSHTTPSResponseSink*>(cell)->JSHTTPSResponseSink::~JSHTTPSResponseSink();
+}
+
+void JSReadableHTTPSResponseSinkController::destroy(JSCell* cell)
+{
+    static_cast<JSReadableHTTPSResponseSinkController*>(cell)->JSReadableHTTPSResponseSinkController::~JSReadableHTTPSResponseSinkController();
+}
+
 JSObject* createJSSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, SinkID sinkID)
 {
     switch (sinkID) {
@@ -387,6 +1025,12 @@ JSObject* createJSSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject,
     case ArrayBufferSink:
         return JSArrayBufferSinkPrototype::create(vm, globalObject, JSArrayBufferSinkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 
+    case HTTPResponseSink:
+        return JSHTTPResponseSinkPrototype::create(vm, globalObject, JSHTTPResponseSinkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+
+    case HTTPSResponseSink:
+        return JSHTTPSResponseSinkPrototype::create(vm, globalObject, JSHTTPSResponseSinkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+
     default:
         RELEASE_ASSERT_NOT_REACHED();
     }
@@ -398,6 +1042,12 @@ JSObject* createJSSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* glob
     case ArrayBufferSink:
         return JSReadableArrayBufferSinkControllerPrototype::create(vm, globalObject, JSReadableArrayBufferSinkControllerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 
+    case HTTPResponseSink:
+        return JSReadableHTTPResponseSinkControllerPrototype::create(vm, globalObject, JSReadableHTTPResponseSinkControllerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+
+    case HTTPSResponseSink:
+        return JSReadableHTTPSResponseSinkControllerPrototype::create(vm, globalObject, JSReadableHTTPSResponseSinkControllerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+
     default:
         RELEASE_ASSERT_NOT_REACHED();
     }
@@ -425,34 +1075,278 @@ extern "C" void* ArrayBufferSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue
     return nullptr;
 }
 
-extern "C" JSC__JSValue ArrayBufferSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, int32_t* bunNativeTag, void** bunNativePtr)
+extern "C" void ArrayBufferSink__detachPtr(JSC__JSValue JSValue0)
+{
+    if (auto* sink = JSC::jsDynamicCast<WebCore::JSArrayBufferSink*>(JSC::JSValue::decode(JSValue0))) {
+        sink->detach();
+        return;
+    }
+
+    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(JSC::JSValue::decode(JSValue0))) {
+        controller->detach();
+        return;
+    }
+}
+
+extern "C" JSC__JSValue ArrayBufferSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void** controllerValue)
 {
     auto& vm = arg0->vm();
     Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
     auto clientData = WebCore::clientData(vm);
     JSC::JSObject* readableStream = JSC::JSValue::decode(stream).getObject();
-
-    if (JSC::JSValue tag = readableStream->get(globalObject, clientData->builtinNames().bunNativeTypePrivateName())) {
-        if (tag.isInt32()) {
-            int32_t tagNumber = tag.toInt32(arg0);
-            if (tagNumber > 0 && tagNumber < 5) {
-                *bunNativeTag = tagNumber;
-                *bunNativePtr = reinterpret_cast<void*>(bitwise_cast<uintptr_t>(readableStream->get(globalObject, clientData->builtinNames().bunNativePtrPrivateName()).asNumber()));
-                return JSC::JSValue::encode(JSC::jsNull());
-            }
-        }
-    }
+    auto scope = DECLARE_CATCH_SCOPE(vm);
 
     JSC::JSValue prototype = globalObject->JSReadableArrayBufferSinkControllerPrototype();
     JSC::Structure* structure = WebCore::JSReadableArrayBufferSinkController::createStructure(vm, globalObject, prototype);
     WebCore::JSReadableArrayBufferSinkController* controller = WebCore::JSReadableArrayBufferSinkController::create(vm, globalObject, structure, sinkPtr);
+    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
+    JSC::JSObject* function = globalObject->getDirect(vm, clientData->builtinNames().assignToStreamPrivateName()).getObject();
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(stream));
+    arguments.append(controller);
+
+    auto result = JSC::call(arg0, function, callData, JSC::jsUndefined(), arguments);
+    if (scope.exception())
+        return JSC::JSValue::encode(scope.exception());
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" void ArrayBufferSink__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
+{
+    WebCore::JSReadableArrayBufferSinkController* controller = JSC::jsCast<WebCore::JSReadableArrayBufferSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
+
+    JSC::JSFunction* function = controller->m_onPull.get();
+    if (function == nullptr)
+        return;
+    JSC::JSGlobalObject* globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(amt));
+    arguments.append(JSC::JSValue::decode(offset));
+
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
+
+extern "C" void ArrayBufferSink__onStart(JSC__JSValue controllerValue)
+{
+}
+
+extern "C" void ArrayBufferSink__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
+{
+    WebCore::JSReadableArrayBufferSinkController* controller = JSC::jsCast<WebCore::JSReadableArrayBufferSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
+
+    JSC::JSFunction* function = controller->m_onClose.get();
+    if (function == nullptr)
+        return;
+    // only call close once
+    controller->m_onClose.clear();
+    JSC::JSGlobalObject* globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(reason));
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
+
+extern "C" JSC__JSValue HTTPResponseSink__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
+{
+    auto& vm = arg0->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
+    JSC::JSValue prototype = globalObject->HTTPResponseSinkPrototype();
+    JSC::Structure* structure = WebCore::JSHTTPResponseSink::createStructure(vm, globalObject, prototype);
+    return JSC::JSValue::encode(WebCore::JSHTTPResponseSink::create(vm, globalObject, structure, sinkPtr));
+}
+
+extern "C" void* HTTPResponseSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
+{
+    JSC::VM& vm = WebCore::getVM(arg0);
+    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPResponseSink*>(JSC::JSValue::decode(JSValue1)))
+        return sink->wrapped();
+
+    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(JSValue1)))
+        return controller->wrapped();
+
+    return nullptr;
+}
+
+extern "C" void HTTPResponseSink__detachPtr(JSC__JSValue JSValue0)
+{
+    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPResponseSink*>(JSC::JSValue::decode(JSValue0))) {
+        sink->detach();
+        return;
+    }
+
+    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(JSValue0))) {
+        controller->detach();
+        return;
+    }
+}
+
+extern "C" JSC__JSValue HTTPResponseSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void** controllerValue)
+{
+    auto& vm = arg0->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
+    auto clientData = WebCore::clientData(vm);
+    JSC::JSObject* readableStream = JSC::JSValue::decode(stream).getObject();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    JSC::JSObject* function = globalObject->getDirect(vm, clientData->builtinNames().assignDirectStreamPrivateName()).getObject();
+    JSC::JSValue prototype = globalObject->JSReadableHTTPResponseSinkControllerPrototype();
+    JSC::Structure* structure = WebCore::JSReadableHTTPResponseSinkController::createStructure(vm, globalObject, prototype);
+    WebCore::JSReadableHTTPResponseSinkController* controller = WebCore::JSReadableHTTPResponseSinkController::create(vm, globalObject, structure, sinkPtr);
+    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
+    JSC::JSObject* function = globalObject->getDirect(vm, clientData->builtinNames().assignToStreamPrivateName()).getObject();
     auto callData = JSC::getCallData(function);
     JSC::MarkedArgumentBuffer arguments;
     arguments.append(JSC::JSValue::decode(stream));
     arguments.append(controller);
 
     auto result = JSC::call(arg0, function, callData, JSC::jsUndefined(), arguments);
+    if (scope.exception())
+        return JSC::JSValue::encode(scope.exception());
+
     return JSC::JSValue::encode(result);
 }
+
+extern "C" void HTTPResponseSink__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
+{
+    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
+
+    JSC::JSFunction* function = controller->m_onPull.get();
+    if (function == nullptr)
+        return;
+    JSC::JSGlobalObject* globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(amt));
+    arguments.append(JSC::JSValue::decode(offset));
+
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
+
+extern "C" void HTTPResponseSink__onStart(JSC__JSValue controllerValue)
+{
+}
+
+extern "C" void HTTPResponseSink__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
+{
+    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
+
+    JSC::JSFunction* function = controller->m_onClose.get();
+    if (function == nullptr)
+        return;
+    // only call close once
+    controller->m_onClose.clear();
+    JSC::JSGlobalObject* globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(reason));
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
+
+extern "C" JSC__JSValue HTTPSResponseSink__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
+{
+    auto& vm = arg0->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
+    JSC::JSValue prototype = globalObject->HTTPSResponseSinkPrototype();
+    JSC::Structure* structure = WebCore::JSHTTPSResponseSink::createStructure(vm, globalObject, prototype);
+    return JSC::JSValue::encode(WebCore::JSHTTPSResponseSink::create(vm, globalObject, structure, sinkPtr));
+}
+
+extern "C" void* HTTPSResponseSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
+{
+    JSC::VM& vm = WebCore::getVM(arg0);
+    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPSResponseSink*>(JSC::JSValue::decode(JSValue1)))
+        return sink->wrapped();
+
+    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(JSValue1)))
+        return controller->wrapped();
+
+    return nullptr;
+}
+
+extern "C" void HTTPSResponseSink__detachPtr(JSC__JSValue JSValue0)
+{
+    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPSResponseSink*>(JSC::JSValue::decode(JSValue0))) {
+        sink->detach();
+        return;
+    }
+
+    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(JSValue0))) {
+        controller->detach();
+        return;
+    }
+}
+
+extern "C" JSC__JSValue HTTPSResponseSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void** controllerValue)
+{
+    auto& vm = arg0->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
+    auto clientData = WebCore::clientData(vm);
+    JSC::JSObject* readableStream = JSC::JSValue::decode(stream).getObject();
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+
+    JSC::JSValue prototype = globalObject->JSReadableHTTPSResponseSinkControllerPrototype();
+    JSC::Structure* structure = WebCore::JSReadableHTTPSResponseSinkController::createStructure(vm, globalObject, prototype);
+    WebCore::JSReadableHTTPSResponseSinkController* controller = WebCore::JSReadableHTTPSResponseSinkController::create(vm, globalObject, structure, sinkPtr);
+    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
+    JSC::JSObject* function = globalObject->getDirect(vm, clientData->builtinNames().assignToStreamPrivateName()).getObject();
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(stream));
+    arguments.append(controller);
+
+    auto result = JSC::call(arg0, function, callData, JSC::jsUndefined(), arguments);
+    if (scope.exception())
+        return JSC::JSValue::encode(scope.exception());
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" void HTTPSResponseSink__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
+{
+    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
+
+    JSC::JSFunction* function = controller->m_onPull.get();
+    if (function == nullptr)
+        return;
+    JSC::JSGlobalObject* globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(amt));
+    arguments.append(JSC::JSValue::decode(offset));
+
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
+
+extern "C" void HTTPSResponseSink__onStart(JSC__JSValue controllerValue)
+{
+}
+
+extern "C" void HTTPSResponseSink__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
+{
+    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
+
+    JSC::JSFunction* function = controller->m_onClose.get();
+    if (function == nullptr)
+        return;
+    // only call close once
+    controller->m_onClose.clear();
+    JSC::JSGlobalObject* globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(reason));
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
diff --git a/src/bun.js/bindings/JSSink.h b/src/bun.js/bindings/JSSink.h
index 4aa522699..014e3449f 100644
--- a/src/bun.js/bindings/JSSink.h
+++ b/src/bun.js/bindings/JSSink.h
@@ -1,6 +1,6 @@
 
 // AUTO-GENERATED FILE. DO NOT EDIT.
-// Generated by /Users/jarred/Code/bun/src/bun.js/generate-jssink.js at 2022-06-15T10:28:21.209Z
+// Generated by /Users/jarred/Code/bun/src/bun.js/generate-jssink.js at 2022-06-26T11:24:51.209Z
 //
 #pragma once
 
@@ -17,148 +17,436 @@ namespace WebCore {
 using namespace JSC;
 
 JSC_DECLARE_HOST_FUNCTION(functionStartDirectStream);
-class JSArrayBufferSinkConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSArrayBufferSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype);
-    static constexpr SinkID Sink = SinkID::ArrayBufferSink;
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSArrayBufferSinkConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = WTFMove(space); });
-    }
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);
-
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-
-private:
-    JSArrayBufferSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)
-        : Base(vm, structure, nativeFunction, nativeFunction)
-
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);
-};
-
-class JSArrayBufferSink final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSArrayBufferSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);
-    static constexpr SinkID Sink = SinkID::ArrayBufferSink;
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSArrayBufferSink, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = WTFMove(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-    ~JSArrayBufferSink();
-
-    void* wrapped() const { return m_sinkPtr; }
-
-    void detach()
-    {
-        m_sinkPtr = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-    void* m_sinkPtr;
-
-    JSArrayBufferSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_sinkPtr = sinkPtr;
-    }
-
-    void finishCreation(JSC::VM&);
-};
-
-class JSReadableArrayBufferSinkController final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSReadableArrayBufferSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);
-    static constexpr SinkID Sink = SinkID::ArrayBufferSink;
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSReadableArrayBufferSinkController, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = WTFMove(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-    ~JSReadableArrayBufferSinkController();
-
-    void* wrapped() const { return m_sinkPtr; }
-    void detach()
-    {
-        m_sinkPtr = nullptr;
-    }
-
-    void start(JSC::JSGlobalObject* globalObject, JSC::JSValue readableStream, JSC::JSFunction* onPull, JSC::JSFunction* onClose);
-    DECLARE_VISIT_CHILDREN;
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-    void* m_sinkPtr;
-    mutable WriteBarrier<JSC::JSFunction> m_onPull;
-    mutable WriteBarrier<JSC::JSFunction> m_onClose;
-    mutable JSC::Weak<JSObject> m_weakReadableStream;
-
-    JSReadableArrayBufferSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_sinkPtr = sinkPtr;
-    }
-
-    void finishCreation(JSC::VM&);
-};
+class JSArrayBufferSinkConstructor final : public JSC::InternalFunction {                                                                                                     
+        public:                                                                                                                                                                     
+            using Base = JSC::InternalFunction;                                                                                                                                     
+            static JSArrayBufferSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
+            static constexpr SinkID Sink = SinkID::ArrayBufferSink;
+                                                                                                                                                                                    
+            static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
+            static constexpr bool needsDestruction = false;                                                                                                                         
+                                                                                                                                                                                    
+            DECLARE_EXPORT_INFO;                                                                                                                                                    
+            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+            {                                                                                                                                                                       
+                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                    return nullptr;                                                                                                                                                 
+                return WebCore::subspaceForImpl<JSArrayBufferSinkConstructor, WebCore::UseCustomHeapCellType::No>(                                                                    
+                    vm,                                                                                                                                                             
+                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
+                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = WTFMove(space); },                                                               
+                    [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },                                                                                       
+                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = WTFMove(space); });                                                                    
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+            {                                                                                                                                                                       
+                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());                                                 
+            }                                                                                                                                                                       
+            void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);   
+            
+            
+            // Must be defined for each specialization class.
+            static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+                                                                                                                                                               
+        private:                                                                                                                                                                    
+            JSArrayBufferSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
+                : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
+                                                                                                                                                                                    
+            {                                                                                                                                                                       
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
+        };                                                                                                                                                                          
+                                                                                                                                                                                    
+        class JSArrayBufferSink final : public JSC::JSDestructibleObject {                                                                                                              
+        public:                                                                                                                                                                     
+            using Base = JSC::JSDestructibleObject;                                                                                                                                 
+            static JSArrayBufferSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+            static constexpr SinkID Sink = SinkID::ArrayBufferSink;                                          
+                                                                                                                                                                                    
+            DECLARE_EXPORT_INFO;                                                                                                                                                    
+            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+            {                                                                                                                                                                       
+                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                    return nullptr;                                                                                                                                                 
+                return WebCore::subspaceForImpl<JSArrayBufferSink, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                    vm,                                                                                                                                                             
+                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
+                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = WTFMove(space); },                                                                          
+                    [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },                                                                                                  
+                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = WTFMove(space); });                                                                               
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            static void destroy(JSC::JSCell*);                                                                                                                                      
+            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+            {                                                                                                                                                                       
+                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            ~JSArrayBufferSink();                                                                                                                                                       
+                                                                                                                                                                                    
+            void* wrapped() const { return m_sinkPtr; }                                                                                                                             
+
+            void detach() {
+                m_sinkPtr = nullptr;
+            }                       
+
+            static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
+                                                                                                                                                                                    
+            void* m_sinkPtr;
+                                                                                                                                                                                    
+            JSArrayBufferSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+                : Base(vm, structure)                                                                                                                                               
+            {                                                                                                                                                                       
+                m_sinkPtr = sinkPtr;                                                                                                                                                
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            void finishCreation(JSC::VM&);                                                                                                                                          
+        };
+
+        class JSReadableArrayBufferSinkController final : public JSC::JSDestructibleObject {                                                                                                              
+            public:                                                                                                                                                                     
+                using Base = JSC::JSDestructibleObject;                                                                                                                                 
+                static JSReadableArrayBufferSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+                static constexpr SinkID Sink = SinkID::ArrayBufferSink;                                          
+                                                                                                                                                                                        
+                DECLARE_EXPORT_INFO;                                                                                                                                                    
+                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+                {                                                                                                                                                                       
+                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                        return nullptr;                                                                                                                                                 
+                    return WebCore::subspaceForImpl<JSReadableArrayBufferSinkController, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                        vm,                                                                                                                                                             
+                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
+                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = WTFMove(space); },                                                                          
+                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
+                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = WTFMove(space); });                                                                               
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                static void destroy(JSC::JSCell*);                                                                                                                                      
+                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+                {                                                                                                                                                                       
+                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                ~JSReadableArrayBufferSinkController();                                                                                                                                                       
+
+
+                void* wrapped() const { return m_sinkPtr; }    
+                void detach() {
+                    m_sinkPtr = nullptr;
+                }
+
+                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSFunction *onPull, JSC::JSFunction *onClose);
+                DECLARE_VISIT_CHILDREN;
+                                                                                                                                                                                        
+                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
+                                                                                                                                                                                        
+                void* m_sinkPtr;
+                mutable WriteBarrier<JSC::JSFunction> m_onPull;
+                mutable WriteBarrier<JSC::JSFunction> m_onClose;
+                mutable JSC::Weak<JSObject> m_weakReadableStream;
+                                                                                                                                                                                        
+                JSReadableArrayBufferSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+                    : Base(vm, structure)                                                                                                                                               
+                {                                                                                                                                                                       
+                    m_sinkPtr = sinkPtr;                                                                                                                                                
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                void finishCreation(JSC::VM&);                                                                                                                                          
+            };
 
 JSC_DECLARE_CUSTOM_GETTER(functionArrayBufferSink__getter);
 
+        
+class JSHTTPResponseSinkConstructor final : public JSC::InternalFunction {                                                                                                     
+        public:                                                                                                                                                                     
+            using Base = JSC::InternalFunction;                                                                                                                                     
+            static JSHTTPResponseSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
+            static constexpr SinkID Sink = SinkID::HTTPResponseSink;
+                                                                                                                                                                                    
+            static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
+            static constexpr bool needsDestruction = false;                                                                                                                         
+                                                                                                                                                                                    
+            DECLARE_EXPORT_INFO;                                                                                                                                                    
+            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+            {                                                                                                                                                                       
+                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                    return nullptr;                                                                                                                                                 
+                return WebCore::subspaceForImpl<JSHTTPResponseSinkConstructor, WebCore::UseCustomHeapCellType::No>(                                                                    
+                    vm,                                                                                                                                                             
+                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
+                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = WTFMove(space); },                                                               
+                    [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },                                                                                       
+                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = WTFMove(space); });                                                                    
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+            {                                                                                                                                                                       
+                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());                                                 
+            }                                                                                                                                                                       
+            void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);   
+            
+            
+            // Must be defined for each specialization class.
+            static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+                                                                                                                                                               
+        private:                                                                                                                                                                    
+            JSHTTPResponseSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
+                : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
+                                                                                                                                                                                    
+            {                                                                                                                                                                       
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
+        };                                                                                                                                                                          
+                                                                                                                                                                                    
+        class JSHTTPResponseSink final : public JSC::JSDestructibleObject {                                                                                                              
+        public:                                                                                                                                                                     
+            using Base = JSC::JSDestructibleObject;                                                                                                                                 
+            static JSHTTPResponseSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+            static constexpr SinkID Sink = SinkID::HTTPResponseSink;                                          
+                                                                                                                                                                                    
+            DECLARE_EXPORT_INFO;                                                                                                                                                    
+            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+            {                                                                                                                                                                       
+                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                    return nullptr;                                                                                                                                                 
+                return WebCore::subspaceForImpl<JSHTTPResponseSink, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                    vm,                                                                                                                                                             
+                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
+                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = WTFMove(space); },                                                                          
+                    [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },                                                                                                  
+                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = WTFMove(space); });                                                                               
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            static void destroy(JSC::JSCell*);                                                                                                                                      
+            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+            {                                                                                                                                                                       
+                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            ~JSHTTPResponseSink();                                                                                                                                                       
+                                                                                                                                                                                    
+            void* wrapped() const { return m_sinkPtr; }                                                                                                                             
+
+            void detach() {
+                m_sinkPtr = nullptr;
+            }                       
+
+            static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
+                                                                                                                                                                                    
+            void* m_sinkPtr;
+                                                                                                                                                                                    
+            JSHTTPResponseSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+                : Base(vm, structure)                                                                                                                                               
+            {                                                                                                                                                                       
+                m_sinkPtr = sinkPtr;                                                                                                                                                
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            void finishCreation(JSC::VM&);                                                                                                                                          
+        };
+
+        class JSReadableHTTPResponseSinkController final : public JSC::JSDestructibleObject {                                                                                                              
+            public:                                                                                                                                                                     
+                using Base = JSC::JSDestructibleObject;                                                                                                                                 
+                static JSReadableHTTPResponseSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+                static constexpr SinkID Sink = SinkID::HTTPResponseSink;                                          
+                                                                                                                                                                                        
+                DECLARE_EXPORT_INFO;                                                                                                                                                    
+                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+                {                                                                                                                                                                       
+                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                        return nullptr;                                                                                                                                                 
+                    return WebCore::subspaceForImpl<JSReadableHTTPResponseSinkController, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                        vm,                                                                                                                                                             
+                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
+                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = WTFMove(space); },                                                                          
+                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
+                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = WTFMove(space); });                                                                               
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                static void destroy(JSC::JSCell*);                                                                                                                                      
+                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+                {                                                                                                                                                                       
+                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                ~JSReadableHTTPResponseSinkController();                                                                                                                                                       
+
+
+                void* wrapped() const { return m_sinkPtr; }    
+                void detach() {
+                    m_sinkPtr = nullptr;
+                }
+
+                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSFunction *onPull, JSC::JSFunction *onClose);
+                DECLARE_VISIT_CHILDREN;
+                                                                                                                                                                                        
+                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
+                                                                                                                                                                                        
+                void* m_sinkPtr;
+                mutable WriteBarrier<JSC::JSFunction> m_onPull;
+                mutable WriteBarrier<JSC::JSFunction> m_onClose;
+                mutable JSC::Weak<JSObject> m_weakReadableStream;
+                                                                                                                                                                                        
+                JSReadableHTTPResponseSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+                    : Base(vm, structure)                                                                                                                                               
+                {                                                                                                                                                                       
+                    m_sinkPtr = sinkPtr;                                                                                                                                                
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                void finishCreation(JSC::VM&);                                                                                                                                          
+            };
+
+JSC_DECLARE_CUSTOM_GETTER(functionHTTPResponseSink__getter);
+
+        
+class JSHTTPSResponseSinkConstructor final : public JSC::InternalFunction {                                                                                                     
+        public:                                                                                                                                                                     
+            using Base = JSC::InternalFunction;                                                                                                                                     
+            static JSHTTPSResponseSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
+            static constexpr SinkID Sink = SinkID::HTTPSResponseSink;
+                                                                                                                                                                                    
+            static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
+            static constexpr bool needsDestruction = false;                                                                                                                         
+                                                                                                                                                                                    
+            DECLARE_EXPORT_INFO;                                                                                                                                                    
+            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+            {                                                                                                                                                                       
+                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                    return nullptr;                                                                                                                                                 
+                return WebCore::subspaceForImpl<JSHTTPSResponseSinkConstructor, WebCore::UseCustomHeapCellType::No>(                                                                    
+                    vm,                                                                                                                                                             
+                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
+                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = WTFMove(space); },                                                               
+                    [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },                                                                                       
+                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = WTFMove(space); });                                                                    
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+            {                                                                                                                                                                       
+                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());                                                 
+            }                                                                                                                                                                       
+            void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);   
+            
+            
+            // Must be defined for each specialization class.
+            static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+                                                                                                                                                               
+        private:                                                                                                                                                                    
+            JSHTTPSResponseSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
+                : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
+                                                                                                                                                                                    
+            {                                                                                                                                                                       
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
+        };                                                                                                                                                                          
+                                                                                                                                                                                    
+        class JSHTTPSResponseSink final : public JSC::JSDestructibleObject {                                                                                                              
+        public:                                                                                                                                                                     
+            using Base = JSC::JSDestructibleObject;                                                                                                                                 
+            static JSHTTPSResponseSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+            static constexpr SinkID Sink = SinkID::HTTPSResponseSink;                                          
+                                                                                                                                                                                    
+            DECLARE_EXPORT_INFO;                                                                                                                                                    
+            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+            {                                                                                                                                                                       
+                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                    return nullptr;                                                                                                                                                 
+                return WebCore::subspaceForImpl<JSHTTPSResponseSink, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                    vm,                                                                                                                                                             
+                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
+                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = WTFMove(space); },                                                                          
+                    [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },                                                                                                  
+                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = WTFMove(space); });                                                                               
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            static void destroy(JSC::JSCell*);                                                                                                                                      
+            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+            {                                                                                                                                                                       
+                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            ~JSHTTPSResponseSink();                                                                                                                                                       
+                                                                                                                                                                                    
+            void* wrapped() const { return m_sinkPtr; }                                                                                                                             
+
+            void detach() {
+                m_sinkPtr = nullptr;
+            }                       
+
+            static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
+                                                                                                                                                                                    
+            void* m_sinkPtr;
+                                                                                                                                                                                    
+            JSHTTPSResponseSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+                : Base(vm, structure)                                                                                                                                               
+            {                                                                                                                                                                       
+                m_sinkPtr = sinkPtr;                                                                                                                                                
+            }                                                                                                                                                                       
+                                                                                                                                                                                    
+            void finishCreation(JSC::VM&);                                                                                                                                          
+        };
+
+        class JSReadableHTTPSResponseSinkController final : public JSC::JSDestructibleObject {                                                                                                              
+            public:                                                                                                                                                                     
+                using Base = JSC::JSDestructibleObject;                                                                                                                                 
+                static JSReadableHTTPSResponseSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+                static constexpr SinkID Sink = SinkID::HTTPSResponseSink;                                          
+                                                                                                                                                                                        
+                DECLARE_EXPORT_INFO;                                                                                                                                                    
+                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+                {                                                                                                                                                                       
+                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                        return nullptr;                                                                                                                                                 
+                    return WebCore::subspaceForImpl<JSReadableHTTPSResponseSinkController, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                        vm,                                                                                                                                                             
+                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
+                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = WTFMove(space); },                                                                          
+                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
+                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = WTFMove(space); });                                                                               
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                static void destroy(JSC::JSCell*);                                                                                                                                      
+                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+                {                                                                                                                                                                       
+                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                ~JSReadableHTTPSResponseSinkController();                                                                                                                                                       
+
+
+                void* wrapped() const { return m_sinkPtr; }    
+                void detach() {
+                    m_sinkPtr = nullptr;
+                }
+
+                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSFunction *onPull, JSC::JSFunction *onClose);
+                DECLARE_VISIT_CHILDREN;
+                                                                                                                                                                                        
+                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
+                                                                                                                                                                                        
+                void* m_sinkPtr;
+                mutable WriteBarrier<JSC::JSFunction> m_onPull;
+                mutable WriteBarrier<JSC::JSFunction> m_onClose;
+                mutable JSC::Weak<JSObject> m_weakReadableStream;
+                                                                                                                                                                                        
+                JSReadableHTTPSResponseSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+                    : Base(vm, structure)                                                                                                                                               
+                {                                                                                                                                                                       
+                    m_sinkPtr = sinkPtr;                                                                                                                                                
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                void finishCreation(JSC::VM&);                                                                                                                                          
+            };
+
+JSC_DECLARE_CUSTOM_GETTER(functionHTTPSResponseSink__getter);
+
+        
+
 JSObject* createJSSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WebCore::SinkID sinkID);
 JSObject* createJSSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WebCore::SinkID sinkID);
 
diff --git a/src/bun.js/bindings/Sink.h b/src/bun.js/bindings/Sink.h
index 3d7435b29..711c3acf9 100644
--- a/src/bun.js/bindings/Sink.h
+++ b/src/bun.js/bindings/Sink.h
@@ -7,9 +7,11 @@ enum SinkID : uint8_t {
     TextSink = 1,
     FileSink = 2,
     HTMLRewriterSink = 3,
+    HTTPResponseSink = 4,
+    HTTPSResponseSink = 5,
 
 };
 static constexpr unsigned numberOfSinkIDs
-    = 4;
+    = 6;
 
 }
\ No newline at end of file
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index 765a54178..3b44172b1 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -1386,6 +1386,27 @@ JSC_DEFINE_HOST_FUNCTION(isAbortSignal, (JSGlobalObject*, CallFrame* callFrame))
     return JSValue::encode(jsBoolean(callFrame->uncheckedArgument(0).inherits<JSAbortSignal>()));
 }
 
+extern "C" void ReadableStream__cancel(JSC__JSValue possibleReadableStream, Zig::GlobalObject* globalObject);
+extern "C" void ReadableStream__cancel(JSC__JSValue possibleReadableStream, Zig::GlobalObject* globalObject)
+{
+    auto* readableStream = jsDynamicCast<JSReadableStream*>(JSC::JSValue::decode(possibleReadableStream));
+    if (UNLIKELY(!readableStream))
+        return;
+
+    WebCore::Exception exception { AbortError };
+    ReadableStream(*globalObject, *readableStream).cancel(exception);
+}
+extern "C" void ReadableStream__detach(JSC__JSValue possibleReadableStream, Zig::GlobalObject* globalObject);
+extern "C" void ReadableStream__detach(JSC__JSValue possibleReadableStream, Zig::GlobalObject* globalObject)
+{
+    auto* readableStream = jsDynamicCast<JSReadableStream*>(JSC::JSValue::decode(possibleReadableStream));
+    if (UNLIKELY(!readableStream))
+        return;
+    auto& vm = globalObject->vm();
+    auto clientData = WebCore::clientData(vm);
+    readableStream->putDirect(vm, clientData->builtinNames().bunNativePtrPrivateName(), JSC::jsUndefined(), 0);
+    readableStream->putDirect(vm, clientData->builtinNames().bunNativeTypePrivateName(), JSC::jsUndefined(), 0);
+}
 extern "C" bool ReadableStream__isDisturbed(JSC__JSValue possibleReadableStream, Zig::GlobalObject* globalObject);
 extern "C" bool ReadableStream__isDisturbed(JSC__JSValue possibleReadableStream, Zig::GlobalObject* globalObject)
 {
@@ -1773,6 +1794,19 @@ void GlobalObject::finishCreation(VM& vm)
             auto* prototype = createJSSinkControllerPrototype(init.vm, init.owner, WebCore::SinkID::ArrayBufferSink);
             init.set(prototype);
         });
+
+    m_JSHTTPResponseControllerPrototype.initLater(
+        [](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSObject>::Initializer& init) {
+            auto* prototype = createJSSinkControllerPrototype(init.vm, init.owner, WebCore::SinkID::HTTPResponseSink);
+            init.set(prototype);
+        });
+
+    m_JSHTTPSResponseControllerPrototype.initLater(
+        [](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSObject>::Initializer& init) {
+            auto* prototype = createJSSinkControllerPrototype(init.vm, init.owner, WebCore::SinkID::HTTPSResponseSink);
+            init.set(prototype);
+        });
+
     m_importMetaObjectStructure.initLater(
         [](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSObject>::Initializer& init) {
             JSC::JSObject* metaProperties = JSC::constructEmptyObject(init.owner, init.owner->objectPrototype(), 10);
@@ -1827,6 +1861,26 @@ void GlobalObject::finishCreation(VM& vm)
             init.setConstructor(constructor);
         });
 
+    m_JSHTTPResponseSinkClassStructure.initLater(
+        [](LazyClassStructure::Initializer& init) {
+            auto* prototype = createJSSinkPrototype(init.vm, init.global, WebCore::SinkID::HTTPResponseSink);
+            auto* structure = JSHTTPResponseSink::createStructure(init.vm, init.global, prototype);
+            auto* constructor = JSHTTPResponseSinkConstructor::create(init.vm, init.global, JSHTTPResponseSinkConstructor::createStructure(init.vm, init.global, init.global->functionPrototype()), jsCast<JSObject*>(prototype));
+            init.setPrototype(prototype);
+            init.setStructure(structure);
+            init.setConstructor(constructor);
+        });
+
+    m_JSHTTPSResponseSinkClassStructure.initLater(
+        [](LazyClassStructure::Initializer& init) {
+            auto* prototype = createJSSinkPrototype(init.vm, init.global, WebCore::SinkID::HTTPSResponseSink);
+            auto* structure = JSHTTPSResponseSink::createStructure(init.vm, init.global, prototype);
+            auto* constructor = JSHTTPSResponseSinkConstructor::create(init.vm, init.global, JSHTTPSResponseSinkConstructor::createStructure(init.vm, init.global, init.global->functionPrototype()), jsCast<JSObject*>(prototype));
+            init.setPrototype(prototype);
+            init.setStructure(structure);
+            init.setConstructor(constructor);
+        });
+
     m_JSFFIFunctionStructure.initLater(
         [](LazyClassStructure::Initializer& init) {
             init.setStructure(Zig::JSFFIFunction::createStructure(init.vm, init.global, init.global->functionPrototype()));
@@ -1954,7 +2008,7 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
     putDirectBuiltinFunction(vm, this, builtinNames.createEmptyReadableStreamPrivateName(), readableStreamCreateEmptyReadableStreamCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     putDirectBuiltinFunction(vm, this, builtinNames.consumeReadableStreamPrivateName(), readableStreamConsumeReadableStreamCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     putDirectBuiltinFunction(vm, this, builtinNames.readableStreamToArrayPrivateName(), readableStreamReadableStreamToArrayCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
-    putDirectBuiltinFunction(vm, this, builtinNames.assignDirectStreamPrivateName(), readableStreamInternalsAssignDirectStreamCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+    putDirectBuiltinFunction(vm, this, builtinNames.assignToStreamPrivateName(), readableStreamInternalsAssignToStreamCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
 
     // putDirectBuiltinFunction(vm, this, builtinNames.loadModulePrivateName(), jsZigGlobalObjectInternalsLoadModuleCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     // putDirectBuiltinFunction(vm, this, builtinNames.requireModulePrivateName(), jsZigGlobalObjectInternalsRequireModuleCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
@@ -2118,13 +2172,13 @@ void GlobalObject::installAPIGlobals(JSClassRef* globals, int count, JSC::VM& vm
         {
 
             JSC::Identifier identifier = JSC::Identifier::fromString(vm, pathToFileURLString);
-            object->putDirectNativeFunction(vm, identifier, 1, functionPathToFileURL, NoIntrinsic,
+            object->putDirectNativeFunction(vm, this, identifier, 1, functionPathToFileURL, NoIntrinsic,
                 JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
         }
 
         {
             JSC::Identifier identifier = JSC::Identifier::fromString(vm, fileURLToPathString);
-            object->putDirectNativeFunction(vm, identifier, 1, fileURLToPathString, NoIntrinsic,
+            object->putDirectNativeFunction(vm, this, identifier, 1, functionFileURLToPath, NoIntrinsic,
                 JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
         }
 
diff --git a/src/bun.js/bindings/ZigGlobalObject.h b/src/bun.js/bindings/ZigGlobalObject.h
index b5a2f99da..24ac66ff1 100644
--- a/src/bun.js/bindings/ZigGlobalObject.h
+++ b/src/bun.js/bindings/ZigGlobalObject.h
@@ -154,10 +154,22 @@ public:
     JSC::Structure* FFIFunctionStructure() { return m_JSFFIFunctionStructure.getInitializedOnMainThread(this); }
     JSC::Structure* NapiClassStructure() { return m_NapiClassStructure.getInitializedOnMainThread(this); }
     JSC::JSObject* ImportMetaObjectPrototype() { return m_importMetaObjectStructure.getInitializedOnMainThread(this); }
+
     JSC::Structure* ArrayBufferSinkStructure() { return m_JSArrayBufferSinkClassStructure.getInitializedOnMainThread(this); }
     JSC::JSObject* ArrayBufferSink() { return m_JSArrayBufferSinkClassStructure.constructorInitializedOnMainThread(this); }
     JSC::JSValue ArrayBufferSinkPrototype() { return m_JSArrayBufferSinkClassStructure.prototypeInitializedOnMainThread(this); }
     JSC::JSValue JSReadableArrayBufferSinkControllerPrototype() { return m_JSArrayBufferControllerPrototype.getInitializedOnMainThread(this); }
+
+    JSC::Structure* HTTPResponseSinkStructure() { return m_JSHTTPResponseSinkClassStructure.getInitializedOnMainThread(this); }
+    JSC::JSObject* HTTPResponseSink() { return m_JSHTTPResponseSinkClassStructure.constructorInitializedOnMainThread(this); }
+    JSC::JSValue HTTPResponseSinkPrototype() { return m_JSHTTPResponseSinkClassStructure.prototypeInitializedOnMainThread(this); }
+    JSC::JSValue JSReadableHTTPResponseSinkControllerPrototype() { return m_JSHTTPResponseControllerPrototype.getInitializedOnMainThread(this); }
+
+    JSC::Structure* HTTPSResponseSinkStructure() { return m_JSHTTPSResponseSinkClassStructure.getInitializedOnMainThread(this); }
+    JSC::JSObject* HTTPSResponseSink() { return m_JSHTTPSResponseSinkClassStructure.constructorInitializedOnMainThread(this); }
+    JSC::JSValue HTTPSResponseSinkPrototype() { return m_JSHTTPSResponseSinkClassStructure.prototypeInitializedOnMainThread(this); }
+    JSC::JSValue JSReadableHTTPSResponseSinkControllerPrototype() { return m_JSHTTPSResponseControllerPrototype.getInitializedOnMainThread(this); }
+
     JSC::JSMap* readableStreamNativeMap() { return m_lazyReadableStreamPrototypeMap.getInitializedOnMainThread(this); }
     JSC::JSMap* requireMap() { return m_requireMap.getInitializedOnMainThread(this); }
 
@@ -184,7 +196,12 @@ private:
     LazyClassStructure m_JSFFIFunctionStructure;
     LazyClassStructure m_NapiClassStructure;
     LazyClassStructure m_JSArrayBufferSinkClassStructure;
+    LazyClassStructure m_JSHTTPResponseSinkClassStructure;
+    LazyClassStructure m_JSHTTPSResponseSinkClassStructure;
+
     LazyProperty<JSGlobalObject, JSObject> m_JSArrayBufferControllerPrototype;
+    LazyProperty<JSGlobalObject, JSObject> m_JSHTTPSResponseControllerPrototype;
+    LazyProperty<JSGlobalObject, JSObject> m_JSHTTPResponseControllerPrototype;
     LazyProperty<JSGlobalObject, JSObject> m_importMetaObjectStructure;
     LazyProperty<JSGlobalObject, JSMap> m_lazyReadableStreamPrototypeMap;
     LazyProperty<JSGlobalObject, JSMap> m_requireMap;
diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 08c3f4fbd..0f5111d28 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -1642,7 +1642,6 @@ pub const JSGlobalObject = extern struct {
         if (comptime bun.Environment.allow_assert) {
             std.debug.assert(this.bunVM_() == @ptrCast(*anyopaque, JSC.VirtualMachine.vm));
         }
-
         return @ptrCast(*JSC.VirtualMachine, @alignCast(std.meta.alignment(JSC.VirtualMachine), this.bunVM_()));
     }
 
@@ -1976,14 +1975,6 @@ pub const JSValue = enum(JSValueReprInt) {
 
     const cppFn = shim.cppFn;
 
-    pub const Encoded = extern union {
-        asInt64: i64,
-        ptr: *JSCell,
-        asBits: extern struct { payload: i32, tag: i32 },
-        asPtr: *anyopaque,
-        asDouble: f64,
-    };
-
     pub const include = "JavaScriptCore/JSValue.h";
     pub const name = "JSC::JSValue";
     pub const namespace = "JSC";
@@ -2380,6 +2371,7 @@ pub const JSValue = enum(JSValueReprInt) {
             u64 => jsNumberFromUint64(@intCast(u64, number)),
             u32 => jsNumberFromInt32(@intCast(i32, number)),
             u52 => jsNumberFromUint64(@as(u64, number)),
+            usize => jsNumberFromUint64(@as(u64, number)),
             comptime_int => switch (number) {
                 0...std.math.maxInt(i32) => jsNumberFromInt32(@intCast(i32, number)),
                 else => jsNumberFromInt64(@intCast(i64, number)),
@@ -2484,16 +2476,12 @@ pub const JSValue = enum(JSValueReprInt) {
         return cppFn("jsNumberFromInt64", .{i});
     }
 
-    pub fn jsNumberFromUint64(i: u64) JSValue {
-        if (i <= std.math.maxInt(i32)) {
-            return jsNumberFromInt32(@intCast(i32, i));
-        }
-
-        if (i <= std.math.maxInt(i52)) {
-            return jsNumberFromDouble(@intToFloat(f64, @intCast(i52, i)));
-        }
+    pub inline fn toJS(this: JSValue, _: *const JSGlobalObject) JSValue {
+        return this;
+    }
 
-        return cppFn("jsNumberFromUint64", .{i});
+    pub fn jsNumberFromUint64(i: u64) JSValue {
+        return FFI.UINT64_TO_JSVALUE(JSC.VirtualMachine.vm.global, i).asJSValue;
     }
 
     pub fn toInt64(this: JSValue) i64 {
@@ -2535,8 +2523,8 @@ pub const JSValue = enum(JSValueReprInt) {
         return cppFn("isUInt32AsAnyInt", .{this});
     }
 
-    pub fn asEncoded(this: JSValue) Encoded {
-        return @bitCast(Encoded, this);
+    pub fn asEncoded(this: JSValue) FFI.EncodedJSValue {
+        return FFI.EncodedJSValue{ .asJSValue = this };
     }
 
     pub fn isInt32(this: JSValue) bool {
@@ -2724,7 +2712,7 @@ pub const JSValue = enum(JSValueReprInt) {
     }
 
     pub fn then(this: JSValue, global: *JSGlobalObject, comptime Then: type, ctx: *Then, comptime onResolve: fn (*Then, globalThis: *JSGlobalObject, args: []const JSC.JSValue) void, comptime onReject: fn (*Then, globalThis: *JSGlobalObject, args: []const JSC.JSValue) void) void {
-        Thenable(Then, onResolve, onReject).then(this, global, ctx);
+        Thenable(Then, onResolve, onReject).then(ctx, this, global);
     }
 
     pub fn getDescription(this: JSValue, global: *JSGlobalObject) ZigString {
@@ -2936,7 +2924,7 @@ pub const JSValue = enum(JSValueReprInt) {
         return @intToPtr(*anyopaque, @bitCast(usize, @enumToInt(this)));
     }
 
-    pub const Extern = [_][]const u8{ "createUninitializedUint8Array", "fromInt64NoTruncate", "fromUInt64NoTruncate", "toUInt64NoTruncate", "asPromise", "toInt64", "_then", "put", "makeWithNameAndPrototype", "parseJSON", "symbolKeyFor", "symbolFor", "getSymbolDescription", "createInternalPromise", "asInternalPromise", "asArrayBuffer_", "getReadableStreamState", "getWritableStreamState", "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", "toZigException", "isException", "toWTFString", "hasProperty", "getPropertyNames", "getDirect", "putDirect", "getIfExists", "asString", "asObject", "asNumber", "isError", "jsNull", "jsUndefined", "jsTDZValue", "jsBoolean", "jsDoubleNumber", "jsNumberFromDouble", "jsNumberFromChar", "jsNumberFromU16", "jsNumberFromInt64", "jsNumberFromUint64", "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" };
+    pub const Extern = [_][]const u8{ "createUninitializedUint8Array", "fromInt64NoTruncate", "fromUInt64NoTruncate", "toUInt64NoTruncate", "asPromise", "toInt64", "_then", "put", "makeWithNameAndPrototype", "parseJSON", "symbolKeyFor", "symbolFor", "getSymbolDescription", "createInternalPromise", "asInternalPromise", "asArrayBuffer_", "getReadableStreamState", "getWritableStreamState", "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", "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" };
 };
 
 extern "c" fn Microtask__run(*Microtask, *JSGlobalObject) void;
diff --git a/src/bun.js/bindings/exports.zig b/src/bun.js/bindings/exports.zig
index b442be742..d87ffd8c1 100644
--- a/src/bun.js/bindings/exports.zig
+++ b/src/bun.js/bindings/exports.zig
@@ -185,6 +185,8 @@ pub const JSReadableStreamFile = JSC.WebCore.FileBlobLoader.Source.JSReadableStr
 
 // Sinks
 pub const JSArrayBufferSink = JSC.WebCore.ArrayBufferSink.JSSink;
+pub const JSHTTPSResponseSink = JSC.WebCore.HTTPSResponseSink.JSSink;
+pub const JSHTTPResponseSink = JSC.WebCore.HTTPResponseSink.JSSink;
 
 // WebSocket
 pub const WebSocketHTTPClient = @import("../../http/websocket_http_client.zig").WebSocketHTTPClient;
@@ -2540,6 +2542,8 @@ comptime {
         NodePath.shim.ref();
         JSReadableStreamBlob.shim.ref();
         JSArrayBufferSink.shim.ref();
+        JSHTTPResponseSink.shim.ref();
+        JSHTTPSResponseSink.shim.ref();
 
         JSReadableStreamFile.shim.ref();
         _ = ZigString__free;
diff --git a/src/bun.js/bindings/headers-cpp.h b/src/bun.js/bindings/headers-cpp.h
index e5de168b4..fed6b41a7 100644
--- a/src/bun.js/bindings/headers-cpp.h
+++ b/src/bun.js/bindings/headers-cpp.h
@@ -1,4 +1,4 @@
-//-- AUTOGENERATED FILE -- 1655958884
+//-- AUTOGENERATED FILE -- 1656242004
 // clang-format off
 #pragma once
 
@@ -256,8 +256,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[32] = {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(Zig::GlobalObject), sizeof(Bun__Readable), sizeof(Bun__Writable), sizeof(Bun__Path), sizeof(ArrayBufferSink)};
+const size_t sizes[34] = {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(Zig::GlobalObject), sizeof(Bun__Readable), sizeof(Bun__Writable), sizeof(Bun__Path), sizeof(ArrayBufferSink), sizeof(HTTPSResponseSink), sizeof(HTTPResponseSink)};
 
-const char* names[32] = {"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", "Zig__GlobalObject", "Bun__Readable", "Bun__Writable", "Bun__Path", "ArrayBufferSink"};
+const char* names[34] = {"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", "Zig__GlobalObject", "Bun__Readable", "Bun__Writable", "Bun__Path", "ArrayBufferSink", "HTTPSResponseSink", "HTTPResponseSink"};
 
-const size_t aligns[32] = {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(Zig::GlobalObject), alignof(Bun__Readable), alignof(Bun__Writable), alignof(Bun__Path), alignof(ArrayBufferSink)};
+const size_t aligns[34] = {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(Zig::GlobalObject), alignof(Bun__Readable), alignof(Bun__Writable), alignof(Bun__Path), alignof(ArrayBufferSink), alignof(HTTPSResponseSink), alignof(HTTPResponseSink)};
diff --git a/src/bun.js/bindings/headers.h b/src/bun.js/bindings/headers.h
index 1caed78b7..c7d0eafd6 100644
--- a/src/bun.js/bindings/headers.h
+++ b/src/bun.js/bindings/headers.h
@@ -1,5 +1,5 @@
 // clang-format off
-//-- AUTOGENERATED FILE -- 1655958884
+//-- AUTOGENERATED FILE -- 1656242004
 #pragma once
 
 #include <stddef.h>
@@ -524,7 +524,6 @@ CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromChar(unsigned char arg0);
 CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromDouble(double arg0);
 CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromInt64(int64_t arg0);
 CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromU16(uint16_t arg0);
-CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromUint64(uint64_t arg0);
 CPP_DECL void JSC__JSValue__jsonStringify(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, uint32_t arg2, ZigString* arg3);
 CPP_DECL JSC__JSValue JSC__JSValue__jsTDZValue();
 CPP_DECL unsigned char JSC__JSValue__jsType(JSC__JSValue JSValue0);
@@ -738,8 +737,12 @@ ZIG_DECL JSC__JSValue ByteBlob__JSReadableStreamSource__load(JSC__JSGlobalObject
 ZIG_DECL JSC__JSValue FileBlobLoader__JSReadableStreamSource__load(JSC__JSGlobalObject* arg0);
 
 #endif
+CPP_DECL JSC__JSValue ArrayBufferSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1, void* arg2, void** arg3);
 CPP_DECL JSC__JSValue ArrayBufferSink__createObject(JSC__JSGlobalObject* arg0, void* arg1);
+CPP_DECL void ArrayBufferSink__detachPtr(JSC__JSValue JSValue0);
 CPP_DECL void* ArrayBufferSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
+CPP_DECL void ArrayBufferSink__onClose(JSC__JSValue JSValue0, JSC__JSValue JSValue1);
+CPP_DECL void ArrayBufferSink__onReady(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSValue JSValue2);
 
 #ifdef __cplusplus
 
@@ -747,11 +750,50 @@ ZIG_DECL JSC__JSValue ArrayBufferSink__close(JSC__JSGlobalObject* arg0, void* ar
 ZIG_DECL JSC__JSValue ArrayBufferSink__construct(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
 ZIG_DECL JSC__JSValue ArrayBufferSink__drain(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
 ZIG_DECL JSC__JSValue ArrayBufferSink__end(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue ArrayBufferSink__endWithSink(void* arg0, JSC__JSGlobalObject* arg1);
 ZIG_DECL void ArrayBufferSink__finalize(void* arg0);
 ZIG_DECL JSC__JSValue ArrayBufferSink__start(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
 ZIG_DECL JSC__JSValue ArrayBufferSink__write(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
 
 #endif
+CPP_DECL JSC__JSValue HTTPSResponseSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1, void* arg2, void** arg3);
+CPP_DECL JSC__JSValue HTTPSResponseSink__createObject(JSC__JSGlobalObject* arg0, void* arg1);
+CPP_DECL void HTTPSResponseSink__detachPtr(JSC__JSValue JSValue0);
+CPP_DECL void* HTTPSResponseSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
+CPP_DECL void HTTPSResponseSink__onClose(JSC__JSValue JSValue0, JSC__JSValue JSValue1);
+CPP_DECL void HTTPSResponseSink__onReady(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSValue JSValue2);
+
+#ifdef __cplusplus
+
+ZIG_DECL JSC__JSValue HTTPSResponseSink__close(JSC__JSGlobalObject* arg0, void* arg1);
+ZIG_DECL JSC__JSValue HTTPSResponseSink__construct(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPSResponseSink__drain(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPSResponseSink__end(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPSResponseSink__endWithSink(void* arg0, JSC__JSGlobalObject* arg1);
+ZIG_DECL void HTTPSResponseSink__finalize(void* arg0);
+ZIG_DECL JSC__JSValue HTTPSResponseSink__start(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPSResponseSink__write(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+
+#endif
+CPP_DECL JSC__JSValue HTTPResponseSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1, void* arg2, void** arg3);
+CPP_DECL JSC__JSValue HTTPResponseSink__createObject(JSC__JSGlobalObject* arg0, void* arg1);
+CPP_DECL void HTTPResponseSink__detachPtr(JSC__JSValue JSValue0);
+CPP_DECL void* HTTPResponseSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
+CPP_DECL void HTTPResponseSink__onClose(JSC__JSValue JSValue0, JSC__JSValue JSValue1);
+CPP_DECL void HTTPResponseSink__onReady(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSValue JSValue2);
+
+#ifdef __cplusplus
+
+ZIG_DECL JSC__JSValue HTTPResponseSink__close(JSC__JSGlobalObject* arg0, void* arg1);
+ZIG_DECL JSC__JSValue HTTPResponseSink__construct(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPResponseSink__drain(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPResponseSink__end(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPResponseSink__endWithSink(void* arg0, JSC__JSGlobalObject* arg1);
+ZIG_DECL void HTTPResponseSink__finalize(void* arg0);
+ZIG_DECL JSC__JSValue HTTPResponseSink__start(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+ZIG_DECL JSC__JSValue HTTPResponseSink__write(JSC__JSGlobalObject* arg0, JSC__CallFrame* arg1);
+
+#endif
 
 #ifdef __cplusplus
 
diff --git a/src/bun.js/bindings/headers.zig b/src/bun.js/bindings/headers.zig
index 77ef7ecb5..54b132d79 100644
--- a/src/bun.js/bindings/headers.zig
+++ b/src/bun.js/bindings/headers.zig
@@ -372,7 +372,6 @@ pub extern fn JSC__JSValue__jsNumberFromChar(arg0: u8) JSC__JSValue;
 pub extern fn JSC__JSValue__jsNumberFromDouble(arg0: f64) JSC__JSValue;
 pub extern fn JSC__JSValue__jsNumberFromInt64(arg0: i64) JSC__JSValue;
 pub extern fn JSC__JSValue__jsNumberFromU16(arg0: u16) JSC__JSValue;
-pub extern fn JSC__JSValue__jsNumberFromUint64(arg0: u64) JSC__JSValue;
 pub extern fn JSC__JSValue__jsonStringify(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, arg2: u32, arg3: [*c]ZigString) void;
 pub extern fn JSC__JSValue__jsTDZValue(...) JSC__JSValue;
 pub extern fn JSC__JSValue__jsType(JSValue0: JSC__JSValue) u8;
@@ -469,6 +468,22 @@ pub extern fn Zig__GlobalObject__resetModuleRegistryMap(arg0: [*c]JSC__JSGlobalO
 pub extern fn Bun__Readable__create(arg0: [*c]Bun__Readable, arg1: [*c]JSC__JSGlobalObject) JSC__JSValue;
 pub extern fn Bun__Writable__create(arg0: [*c]Bun__Writable, arg1: [*c]JSC__JSGlobalObject) JSC__JSValue;
 pub extern fn Bun__Path__create(arg0: [*c]JSC__JSGlobalObject, arg1: bool) JSC__JSValue;
+pub extern fn ArrayBufferSink__assignToStream(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue, arg2: ?*anyopaque, arg3: [*c]*anyopaque) JSC__JSValue;
 pub extern fn ArrayBufferSink__createObject(arg0: [*c]JSC__JSGlobalObject, arg1: ?*anyopaque) JSC__JSValue;
+pub extern fn ArrayBufferSink__detachPtr(JSValue0: JSC__JSValue) void;
 pub extern fn ArrayBufferSink__fromJS(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue) ?*anyopaque;
+pub extern fn ArrayBufferSink__onClose(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue) void;
+pub extern fn ArrayBufferSink__onReady(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue, JSValue2: JSC__JSValue) void;
+pub extern fn HTTPSResponseSink__assignToStream(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue, arg2: ?*anyopaque, arg3: [*c]*anyopaque) JSC__JSValue;
+pub extern fn HTTPSResponseSink__createObject(arg0: [*c]JSC__JSGlobalObject, arg1: ?*anyopaque) JSC__JSValue;
+pub extern fn HTTPSResponseSink__detachPtr(JSValue0: JSC__JSValue) void;
+pub extern fn HTTPSResponseSink__fromJS(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue) ?*anyopaque;
+pub extern fn HTTPSResponseSink__onClose(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue) void;
+pub extern fn HTTPSResponseSink__onReady(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue, JSValue2: JSC__JSValue) void;
+pub extern fn HTTPResponseSink__assignToStream(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue, arg2: ?*anyopaque, arg3: [*c]*anyopaque) JSC__JSValue;
+pub extern fn HTTPResponseSink__createObject(arg0: [*c]JSC__JSGlobalObject, arg1: ?*anyopaque) JSC__JSValue;
+pub extern fn HTTPResponseSink__detachPtr(JSValue0: JSC__JSValue) void;
+pub extern fn HTTPResponseSink__fromJS(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue) ?*anyopaque;
+pub extern fn HTTPResponseSink__onClose(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue) void;
+pub extern fn HTTPResponseSink__onReady(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue, JSValue2: JSC__JSValue) void;
 pub extern fn ZigException__fromException(arg0: [*c]JSC__Exception) ZigException;
diff --git a/src/bun.js/bindings/webcore/ReadableStream.h b/src/bun.js/bindings/webcore/ReadableStream.h
index f50185865..9d3558d0e 100644
--- a/src/bun.js/bindings/webcore/ReadableStream.h
+++ b/src/bun.js/bindings/webcore/ReadableStream.h
@@ -59,7 +59,6 @@ public:
         return guarded();
     }
 
-private:
     ReadableStream(JSDOMGlobalObject& globalObject, JSReadableStream& readableStream)
         : DOMGuarded<JSReadableStream>(globalObject, readableStream)
     {
diff --git a/src/bun.js/bindings/webcore/WebCoreBuiltins.h b/src/bun.js/bindings/webcore/WebCoreBuiltins.h
index abd53c142..60c47c661 100644
--- a/src/bun.js/bindings/webcore/WebCoreBuiltins.h
+++ b/src/bun.js/bindings/webcore/WebCoreBuiltins.h
@@ -6,7 +6,7 @@
  * Copyright (c) 2015, 2016, 2017 Canon Inc.
  * Copyright (c) 2016, 2020 Apple Inc. All rights reserved.
  * Copyright (c) 2022 Codeblog Corp. All rights reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -15,7 +15,7 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
@@ -27,7 +27,7 @@
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
  */
 
 // DO NOT EDIT THIS FILE. It is automatically generated from JavaScript files for
@@ -64,9 +64,9 @@ extern const JSC::ConstructAbility s_byteLengthQueuingStrategyInitializeByteLeng
 extern const JSC::ConstructorKind s_byteLengthQueuingStrategyInitializeByteLengthQueuingStrategyCodeConstructorKind;
 
 #define WEBCORE_FOREACH_BYTELENGTHQUEUINGSTRATEGY_BUILTIN_DATA(macro) \
-    macro(highWaterMark, byteLengthQueuingStrategyHighWaterMark, 0) \
-    macro(size, byteLengthQueuingStrategySize, 1) \
-    macro(initializeByteLengthQueuingStrategy, byteLengthQueuingStrategyInitializeByteLengthQueuingStrategy, 1) \
+    macro(highWaterMark, byteLengthQueuingStrategyHighWaterMark, 0)   \
+        macro(size, byteLengthQueuingStrategySize, 1)                 \
+            macro(initializeByteLengthQueuingStrategy, byteLengthQueuingStrategyInitializeByteLengthQueuingStrategy, 1)
 
 /* CountQueuingStrategy */
 extern const char* const s_countQueuingStrategyHighWaterMarkCode;
@@ -83,9 +83,9 @@ extern const JSC::ConstructAbility s_countQueuingStrategyInitializeCountQueuingS
 extern const JSC::ConstructorKind s_countQueuingStrategyInitializeCountQueuingStrategyCodeConstructorKind;
 
 #define WEBCORE_FOREACH_COUNTQUEUINGSTRATEGY_BUILTIN_DATA(macro) \
-    macro(highWaterMark, countQueuingStrategyHighWaterMark, 0) \
-    macro(size, countQueuingStrategySize, 0) \
-    macro(initializeCountQueuingStrategy, countQueuingStrategyInitializeCountQueuingStrategy, 1) \
+    macro(highWaterMark, countQueuingStrategyHighWaterMark, 0)   \
+        macro(size, countQueuingStrategySize, 0)                 \
+            macro(initializeCountQueuingStrategy, countQueuingStrategyInitializeCountQueuingStrategy, 1)
 
 /* JSBufferConstructor */
 extern const char* const s_jsBufferConstructorFromCode;
@@ -94,7 +94,7 @@ extern const JSC::ConstructAbility s_jsBufferConstructorFromCodeConstructAbility
 extern const JSC::ConstructorKind s_jsBufferConstructorFromCodeConstructorKind;
 
 #define WEBCORE_FOREACH_JSBUFFERCONSTRUCTOR_BUILTIN_DATA(macro) \
-    macro(from, jsBufferConstructorFrom, 1) \
+    macro(from, jsBufferConstructorFrom, 1)
 
 /* JSBufferPrototype */
 extern const char* const s_jsBufferPrototypeSetBigUint64Code;
@@ -326,64 +326,64 @@ extern const int s_jsBufferPrototypeInitializeBunBufferCodeLength;
 extern const JSC::ConstructAbility s_jsBufferPrototypeInitializeBunBufferCodeConstructAbility;
 extern const JSC::ConstructorKind s_jsBufferPrototypeInitializeBunBufferCodeConstructorKind;
 
-#define WEBCORE_FOREACH_JSBUFFERPROTOTYPE_BUILTIN_DATA(macro) \
-    macro(setBigUint64, jsBufferPrototypeSetBigUint64, 3) \
-    macro(readInt8, jsBufferPrototypeReadInt8, 1) \
-    macro(readUInt8, jsBufferPrototypeReadUInt8, 1) \
-    macro(readInt16LE, jsBufferPrototypeReadInt16LE, 1) \
-    macro(readInt16BE, jsBufferPrototypeReadInt16BE, 1) \
-    macro(readUInt16LE, jsBufferPrototypeReadUInt16LE, 1) \
-    macro(readUInt16BE, jsBufferPrototypeReadUInt16BE, 1) \
-    macro(readInt32LE, jsBufferPrototypeReadInt32LE, 1) \
-    macro(readInt32BE, jsBufferPrototypeReadInt32BE, 1) \
-    macro(readUInt32LE, jsBufferPrototypeReadUInt32LE, 1) \
-    macro(readUInt32BE, jsBufferPrototypeReadUInt32BE, 1) \
-    macro(readFloatLE, jsBufferPrototypeReadFloatLE, 1) \
-    macro(readFloatBE, jsBufferPrototypeReadFloatBE, 1) \
-    macro(readDoubleLE, jsBufferPrototypeReadDoubleLE, 1) \
-    macro(readDoubleBE, jsBufferPrototypeReadDoubleBE, 1) \
-    macro(readBigInt64LE, jsBufferPrototypeReadBigInt64LE, 1) \
-    macro(readBigInt64BE, jsBufferPrototypeReadBigInt64BE, 1) \
-    macro(readBigUInt64LE, jsBufferPrototypeReadBigUInt64LE, 1) \
-    macro(readBigUInt64BE, jsBufferPrototypeReadBigUInt64BE, 1) \
-    macro(writeInt8, jsBufferPrototypeWriteInt8, 2) \
-    macro(writeUInt8, jsBufferPrototypeWriteUInt8, 2) \
-    macro(writeInt16LE, jsBufferPrototypeWriteInt16LE, 2) \
-    macro(writeInt16BE, jsBufferPrototypeWriteInt16BE, 2) \
-    macro(writeUInt16LE, jsBufferPrototypeWriteUInt16LE, 2) \
-    macro(writeUInt16BE, jsBufferPrototypeWriteUInt16BE, 2) \
-    macro(writeInt32LE, jsBufferPrototypeWriteInt32LE, 2) \
-    macro(writeInt32BE, jsBufferPrototypeWriteInt32BE, 2) \
-    macro(writeUInt32LE, jsBufferPrototypeWriteUInt32LE, 2) \
-    macro(writeUInt32BE, jsBufferPrototypeWriteUInt32BE, 2) \
-    macro(writeFloatLE, jsBufferPrototypeWriteFloatLE, 2) \
-    macro(writeFloatBE, jsBufferPrototypeWriteFloatBE, 2) \
-    macro(writeDoubleLE, jsBufferPrototypeWriteDoubleLE, 2) \
-    macro(writeDoubleBE, jsBufferPrototypeWriteDoubleBE, 2) \
-    macro(writeBigInt64LE, jsBufferPrototypeWriteBigInt64LE, 2) \
-    macro(writeBigInt64BE, jsBufferPrototypeWriteBigInt64BE, 2) \
-    macro(writeBigUInt64LE, jsBufferPrototypeWriteBigUInt64LE, 2) \
-    macro(writeBigUInt64BE, jsBufferPrototypeWriteBigUInt64BE, 2) \
-    macro(slice, jsBufferPrototypeSlice, 2) \
-    macro(utf8Write, jsBufferPrototypeUtf8Write, 3) \
-    macro(ucs2Write, jsBufferPrototypeUcs2Write, 3) \
-    macro(utf16leWrite, jsBufferPrototypeUtf16leWrite, 3) \
-    macro(latin1Write, jsBufferPrototypeLatin1Write, 3) \
-    macro(asciiWrite, jsBufferPrototypeAsciiWrite, 3) \
-    macro(base64Write, jsBufferPrototypeBase64Write, 3) \
-    macro(base64urlWrite, jsBufferPrototypeBase64urlWrite, 3) \
-    macro(hexWrite, jsBufferPrototypeHexWrite, 3) \
-    macro(utf8Slice, jsBufferPrototypeUtf8Slice, 2) \
-    macro(ucs2Slice, jsBufferPrototypeUcs2Slice, 2) \
-    macro(utf16leSlice, jsBufferPrototypeUtf16leSlice, 2) \
-    macro(latin1Slice, jsBufferPrototypeLatin1Slice, 2) \
-    macro(asciiSlice, jsBufferPrototypeAsciiSlice, 2) \
-    macro(base64Slice, jsBufferPrototypeBase64Slice, 2) \
-    macro(base64urlSlice, jsBufferPrototypeBase64urlSlice, 2) \
-    macro(hexSlice, jsBufferPrototypeHexSlice, 2) \
-    macro(toJSON, jsBufferPrototypeToJSON, 0) \
-    macro(subarray, jsBufferPrototypeSubarray, 2) \
-    macro(initializeBunBuffer, jsBufferPrototypeInitializeBunBuffer, 1) \
+#define WEBCORE_FOREACH_JSBUFFERPROTOTYPE_BUILTIN_DATA(macro)                                                                                                                                                                                                                 \
+    macro(setBigUint64, jsBufferPrototypeSetBigUint64, 3)                                                                                                                                                                                                                     \
+        macro(readInt8, jsBufferPrototypeReadInt8, 1)                                                                                                                                                                                                                         \
+            macro(readUInt8, jsBufferPrototypeReadUInt8, 1)                                                                                                                                                                                                                   \
+                macro(readInt16LE, jsBufferPrototypeReadInt16LE, 1)                                                                                                                                                                                                           \
+                    macro(readInt16BE, jsBufferPrototypeReadInt16BE, 1)                                                                                                                                                                                                       \
+                        macro(readUInt16LE, jsBufferPrototypeReadUInt16LE, 1)                                                                                                                                                                                                 \
+                            macro(readUInt16BE, jsBufferPrototypeReadUInt16BE, 1)                                                                                                                                                                                             \
+                                macro(readInt32LE, jsBufferPrototypeReadInt32LE, 1)                                                                                                                                                                                           \
+                                    macro(readInt32BE, jsBufferPrototypeReadInt32BE, 1)                                                                                                                                                                                       \
+                                        macro(readUInt32LE, jsBufferPrototypeReadUInt32LE, 1)                                                                                                                                                                                 \
+                                            macro(readUInt32BE, jsBufferPrototypeReadUInt32BE, 1)                                                                                                                                                                             \
+                                                macro(readFloatLE, jsBufferPrototypeReadFloatLE, 1)                                                                                                                                                                           \
+                                                    macro(readFloatBE, jsBufferPrototypeReadFloatBE, 1)                                                                                                                                                                       \
+                                                        macro(readDoubleLE, jsBufferPrototypeReadDoubleLE, 1)                                                                                                                                                                 \
+                                                            macro(readDoubleBE, jsBufferPrototypeReadDoubleBE, 1)                                                                                                                                                             \
+                                                                macro(readBigInt64LE, jsBufferPrototypeReadBigInt64LE, 1)                                                                                                                                                     \
+                                                                    macro(readBigInt64BE, jsBufferPrototypeReadBigInt64BE, 1)                                                                                                                                                 \
+                                                                        macro(readBigUInt64LE, jsBufferPrototypeReadBigUInt64LE, 1)                                                                                                                                           \
+                                                                            macro(readBigUInt64BE, jsBufferPrototypeReadBigUInt64BE, 1)                                                                                                                                       \
+                                                                                macro(writeInt8, jsBufferPrototypeWriteInt8, 2)                                                                                                                                               \
+                                                                                    macro(writeUInt8, jsBufferPrototypeWriteUInt8, 2)                                                                                                                                         \
+                                                                                        macro(writeInt16LE, jsBufferPrototypeWriteInt16LE, 2)                                                                                                                                 \
+                                                                                            macro(writeInt16BE, jsBufferPrototypeWriteInt16BE, 2)                                                                                                                             \
+                                                                                                macro(writeUInt16LE, jsBufferPrototypeWriteUInt16LE, 2)                                                                                                                       \
+                                                                                                    macro(writeUInt16BE, jsBufferPrototypeWriteUInt16BE, 2)                                                                                                                   \
+                                                                                                        macro(writeInt32LE, jsBufferPrototypeWriteInt32LE, 2)                                                                                                                 \
+                                                                                                            macro(writeInt32BE, jsBufferPrototypeWriteInt32BE, 2)                                                                                                             \
+                                                                                                                macro(writeUInt32LE, jsBufferPrototypeWriteUInt32LE, 2)                                                                                                       \
+                                                                                                                    macro(writeUInt32BE, jsBufferPrototypeWriteUInt32BE, 2)                                                                                                   \
+                                                                                                                        macro(writeFloatLE, jsBufferPrototypeWriteFloatLE, 2)                                                                                                 \
+                                                                                                                            macro(writeFloatBE, jsBufferPrototypeWriteFloatBE, 2)                                                                                             \
+                                                                                                                                macro(writeDoubleLE, jsBufferPrototypeWriteDoubleLE, 2)                                                                                       \
+                                                                                                                                    macro(writeDoubleBE, jsBufferPrototypeWriteDoubleBE, 2)                                                                                   \
+                                                                                                                                        macro(writeBigInt64LE, jsBufferPrototypeWriteBigInt64LE, 2)                                                                           \
+                                                                                                                                            macro(writeBigInt64BE, jsBufferPrototypeWriteBigInt64BE, 2)                                                                       \
+                                                                                                                                                macro(writeBigUInt64LE, jsBufferPrototypeWriteBigUInt64LE, 2)                                                                 \
+                                                                                                                                                    macro(writeBigUInt64BE, jsBufferPrototypeWriteBigUInt64BE, 2)                                                             \
+                                                                                                                                                        macro(slice, jsBufferPrototypeSlice, 2)                                                                               \
+                                                                                                                                                            macro(utf8Write, jsBufferPrototypeUtf8Write, 3)                                                                   \
+                                                                                                                                                                macro(ucs2Write, jsBufferPrototypeUcs2Write, 3)                                                               \
+                                                                                                                                                                    macro(utf16leWrite, jsBufferPrototypeUtf16leWrite, 3)                                                     \
+                                                                                                                                                                        macro(latin1Write, jsBufferPrototypeLatin1Write, 3)                                                   \
+                                                                                                                                                                            macro(asciiWrite, jsBufferPrototypeAsciiWrite, 3)                                                 \
+                                                                                                                                                                                macro(base64Write, jsBufferPrototypeBase64Write, 3)                                           \
+                                                                                                                                                                                    macro(base64urlWrite, jsBufferPrototypeBase64urlWrite, 3)                                 \
+                                                                                                                                                                                        macro(hexWrite, jsBufferPrototypeHexWrite, 3)                                         \
+                                                                                                                                                                                            macro(utf8Slice, jsBufferPrototypeUtf8Slice, 2)                                   \
+                                                                                                                                                                                                macro(ucs2Slice, jsBufferPrototypeUcs2Slice, 2)                               \
+                                                                                                                                                                                                    macro(utf16leSlice, jsBufferPrototypeUtf16leSlice, 2)                     \
+                                                                                                                                                                                                        macro(latin1Slice, jsBufferPrototypeLatin1Slice, 2)                   \
+                                                                                                                                                                                                            macro(asciiSlice, jsBufferPrototypeAsciiSlice, 2)                 \
+                                                                                                                                                                                                                macro(base64Slice, jsBufferPrototypeBase64Slice, 2)           \
+                                                                                                                                                                                                                    macro(base64urlSlice, jsBufferPrototypeBase64urlSlice, 2) \
+                                                                                                                                                                                                                        macro(hexSlice, jsBufferPrototypeHexSlice, 2)         \
+                                                                                                                                                                                                                            macro(toJSON, jsBufferPrototypeToJSON, 0)         \
+                                                                                                                                                                                                                                macro(subarray, jsBufferPrototypeSubarray, 2) \
+                                                                                                                                                                                                                                    macro(initializeBunBuffer, jsBufferPrototypeInitializeBunBuffer, 1)
 
 /* JSZigGlobalObject */
 extern const char* const s_jsZigGlobalObjectRequireCode;
@@ -392,7 +392,7 @@ extern const JSC::ConstructAbility s_jsZigGlobalObjectRequireCodeConstructAbilit
 extern const JSC::ConstructorKind s_jsZigGlobalObjectRequireCodeConstructorKind;
 
 #define WEBCORE_FOREACH_JSZIGGLOBALOBJECT_BUILTIN_DATA(macro) \
-    macro(require, jsZigGlobalObjectRequire, 1) \
+    macro(require, jsZigGlobalObjectRequire, 1)
 
 /* ReadableByteStreamController */
 extern const char* const s_readableByteStreamControllerInitializeReadableByteStreamControllerCode;
@@ -420,13 +420,13 @@ extern const int s_readableByteStreamControllerDesiredSizeCodeLength;
 extern const JSC::ConstructAbility s_readableByteStreamControllerDesiredSizeCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableByteStreamControllerDesiredSizeCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLEBYTESTREAMCONTROLLER_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_READABLEBYTESTREAMCONTROLLER_BUILTIN_DATA(macro)                                                 \
     macro(initializeReadableByteStreamController, readableByteStreamControllerInitializeReadableByteStreamController, 3) \
-    macro(enqueue, readableByteStreamControllerEnqueue, 1) \
-    macro(error, readableByteStreamControllerError, 1) \
-    macro(close, readableByteStreamControllerClose, 0) \
-    macro(byobRequest, readableByteStreamControllerByobRequest, 0) \
-    macro(desiredSize, readableByteStreamControllerDesiredSize, 0) \
+        macro(enqueue, readableByteStreamControllerEnqueue, 1)                                                           \
+            macro(error, readableByteStreamControllerError, 1)                                                           \
+                macro(close, readableByteStreamControllerClose, 0)                                                       \
+                    macro(byobRequest, readableByteStreamControllerByobRequest, 0)                                       \
+                        macro(desiredSize, readableByteStreamControllerDesiredSize, 0)
 
 /* ReadableByteStreamInternals */
 extern const char* const s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCode;
@@ -574,43 +574,43 @@ extern const int s_readableByteStreamInternalsReadableStreamAddReadIntoRequestCo
 extern const JSC::ConstructAbility s_readableByteStreamInternalsReadableStreamAddReadIntoRequestCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableByteStreamInternalsReadableStreamAddReadIntoRequestCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLEBYTESTREAMINTERNALS_BUILTIN_DATA(macro) \
-    macro(privateInitializeReadableByteStreamController, readableByteStreamInternalsPrivateInitializeReadableByteStreamController, 3) \
-    macro(readableStreamByteStreamControllerStart, readableByteStreamInternalsReadableStreamByteStreamControllerStart, 1) \
-    macro(privateInitializeReadableStreamBYOBRequest, readableByteStreamInternalsPrivateInitializeReadableStreamBYOBRequest, 2) \
-    macro(isReadableByteStreamController, readableByteStreamInternalsIsReadableByteStreamController, 1) \
-    macro(isReadableStreamBYOBRequest, readableByteStreamInternalsIsReadableStreamBYOBRequest, 1) \
-    macro(isReadableStreamBYOBReader, readableByteStreamInternalsIsReadableStreamBYOBReader, 1) \
-    macro(readableByteStreamControllerCancel, readableByteStreamInternalsReadableByteStreamControllerCancel, 2) \
-    macro(readableByteStreamControllerError, readableByteStreamInternalsReadableByteStreamControllerError, 2) \
-    macro(readableByteStreamControllerClose, readableByteStreamInternalsReadableByteStreamControllerClose, 1) \
-    macro(readableByteStreamControllerClearPendingPullIntos, readableByteStreamInternalsReadableByteStreamControllerClearPendingPullIntos, 1) \
-    macro(readableByteStreamControllerGetDesiredSize, readableByteStreamInternalsReadableByteStreamControllerGetDesiredSize, 1) \
-    macro(readableStreamHasBYOBReader, readableByteStreamInternalsReadableStreamHasBYOBReader, 1) \
-    macro(readableStreamHasDefaultReader, readableByteStreamInternalsReadableStreamHasDefaultReader, 1) \
-    macro(readableByteStreamControllerHandleQueueDrain, readableByteStreamInternalsReadableByteStreamControllerHandleQueueDrain, 1) \
-    macro(readableByteStreamControllerPull, readableByteStreamInternalsReadableByteStreamControllerPull, 1) \
-    macro(readableByteStreamControllerShouldCallPull, readableByteStreamInternalsReadableByteStreamControllerShouldCallPull, 1) \
-    macro(readableByteStreamControllerCallPullIfNeeded, readableByteStreamInternalsReadableByteStreamControllerCallPullIfNeeded, 1) \
-    macro(transferBufferToCurrentRealm, readableByteStreamInternalsTransferBufferToCurrentRealm, 1) \
-    macro(readableStreamReaderKind, readableByteStreamInternalsReadableStreamReaderKind, 1) \
-    macro(readableByteStreamControllerEnqueue, readableByteStreamInternalsReadableByteStreamControllerEnqueue, 2) \
-    macro(readableByteStreamControllerEnqueueChunk, readableByteStreamInternalsReadableByteStreamControllerEnqueueChunk, 4) \
-    macro(readableByteStreamControllerRespondWithNewView, readableByteStreamInternalsReadableByteStreamControllerRespondWithNewView, 2) \
-    macro(readableByteStreamControllerRespond, readableByteStreamInternalsReadableByteStreamControllerRespond, 2) \
-    macro(readableByteStreamControllerRespondInternal, readableByteStreamInternalsReadableByteStreamControllerRespondInternal, 2) \
-    macro(readableByteStreamControllerRespondInReadableState, readableByteStreamInternalsReadableByteStreamControllerRespondInReadableState, 3) \
-    macro(readableByteStreamControllerRespondInClosedState, readableByteStreamInternalsReadableByteStreamControllerRespondInClosedState, 2) \
-    macro(readableByteStreamControllerProcessPullDescriptors, readableByteStreamInternalsReadableByteStreamControllerProcessPullDescriptors, 1) \
-    macro(readableByteStreamControllerFillDescriptorFromQueue, readableByteStreamInternalsReadableByteStreamControllerFillDescriptorFromQueue, 2) \
-    macro(readableByteStreamControllerShiftPendingDescriptor, readableByteStreamInternalsReadableByteStreamControllerShiftPendingDescriptor, 1) \
-    macro(readableByteStreamControllerInvalidateBYOBRequest, readableByteStreamInternalsReadableByteStreamControllerInvalidateBYOBRequest, 1) \
-    macro(readableByteStreamControllerCommitDescriptor, readableByteStreamInternalsReadableByteStreamControllerCommitDescriptor, 2) \
-    macro(readableByteStreamControllerConvertDescriptor, readableByteStreamInternalsReadableByteStreamControllerConvertDescriptor, 1) \
-    macro(readableStreamFulfillReadIntoRequest, readableByteStreamInternalsReadableStreamFulfillReadIntoRequest, 3) \
-    macro(readableStreamBYOBReaderRead, readableByteStreamInternalsReadableStreamBYOBReaderRead, 2) \
-    macro(readableByteStreamControllerPullInto, readableByteStreamInternalsReadableByteStreamControllerPullInto, 2) \
-    macro(readableStreamAddReadIntoRequest, readableByteStreamInternalsReadableStreamAddReadIntoRequest, 1) \
+#define WEBCORE_FOREACH_READABLEBYTESTREAMINTERNALS_BUILTIN_DATA(macro)                                                                                                                                                                                           \
+    macro(privateInitializeReadableByteStreamController, readableByteStreamInternalsPrivateInitializeReadableByteStreamController, 3)                                                                                                                             \
+        macro(readableStreamByteStreamControllerStart, readableByteStreamInternalsReadableStreamByteStreamControllerStart, 1)                                                                                                                                     \
+            macro(privateInitializeReadableStreamBYOBRequest, readableByteStreamInternalsPrivateInitializeReadableStreamBYOBRequest, 2)                                                                                                                           \
+                macro(isReadableByteStreamController, readableByteStreamInternalsIsReadableByteStreamController, 1)                                                                                                                                               \
+                    macro(isReadableStreamBYOBRequest, readableByteStreamInternalsIsReadableStreamBYOBRequest, 1)                                                                                                                                                 \
+                        macro(isReadableStreamBYOBReader, readableByteStreamInternalsIsReadableStreamBYOBReader, 1)                                                                                                                                               \
+                            macro(readableByteStreamControllerCancel, readableByteStreamInternalsReadableByteStreamControllerCancel, 2)                                                                                                                           \
+                                macro(readableByteStreamControllerError, readableByteStreamInternalsReadableByteStreamControllerError, 2)                                                                                                                         \
+                                    macro(readableByteStreamControllerClose, readableByteStreamInternalsReadableByteStreamControllerClose, 1)                                                                                                                     \
+                                        macro(readableByteStreamControllerClearPendingPullIntos, readableByteStreamInternalsReadableByteStreamControllerClearPendingPullIntos, 1)                                                                                 \
+                                            macro(readableByteStreamControllerGetDesiredSize, readableByteStreamInternalsReadableByteStreamControllerGetDesiredSize, 1)                                                                                           \
+                                                macro(readableStreamHasBYOBReader, readableByteStreamInternalsReadableStreamHasBYOBReader, 1)                                                                                                                     \
+                                                    macro(readableStreamHasDefaultReader, readableByteStreamInternalsReadableStreamHasDefaultReader, 1)                                                                                                           \
+                                                        macro(readableByteStreamControllerHandleQueueDrain, readableByteStreamInternalsReadableByteStreamControllerHandleQueueDrain, 1)                                                                           \
+                                                            macro(readableByteStreamControllerPull, readableByteStreamInternalsReadableByteStreamControllerPull, 1)                                                                                               \
+                                                                macro(readableByteStreamControllerShouldCallPull, readableByteStreamInternalsReadableByteStreamControllerShouldCallPull, 1)                                                                       \
+                                                                    macro(readableByteStreamControllerCallPullIfNeeded, readableByteStreamInternalsReadableByteStreamControllerCallPullIfNeeded, 1)                                                               \
+                                                                        macro(transferBufferToCurrentRealm, readableByteStreamInternalsTransferBufferToCurrentRealm, 1)                                                                                           \
+                                                                            macro(readableStreamReaderKind, readableByteStreamInternalsReadableStreamReaderKind, 1)                                                                                               \
+                                                                                macro(readableByteStreamControllerEnqueue, readableByteStreamInternalsReadableByteStreamControllerEnqueue, 2)                                                                     \
+                                                                                    macro(readableByteStreamControllerEnqueueChunk, readableByteStreamInternalsReadableByteStreamControllerEnqueueChunk, 4)                                                       \
+                                                                                        macro(readableByteStreamControllerRespondWithNewView, readableByteStreamInternalsReadableByteStreamControllerRespondWithNewView, 2)                                       \
+                                                                                            macro(readableByteStreamControllerRespond, readableByteStreamInternalsReadableByteStreamControllerRespond, 2)                                                         \
+                                                                                                macro(readableByteStreamControllerRespondInternal, readableByteStreamInternalsReadableByteStreamControllerRespondInternal, 2)                                     \
+                                                                                                    macro(readableByteStreamControllerRespondInReadableState, readableByteStreamInternalsReadableByteStreamControllerRespondInReadableState, 3)                   \
+                                                                                                        macro(readableByteStreamControllerRespondInClosedState, readableByteStreamInternalsReadableByteStreamControllerRespondInClosedState, 2)                   \
+                                                                                                            macro(readableByteStreamControllerProcessPullDescriptors, readableByteStreamInternalsReadableByteStreamControllerProcessPullDescriptors, 1)           \
+                                                                                                                macro(readableByteStreamControllerFillDescriptorFromQueue, readableByteStreamInternalsReadableByteStreamControllerFillDescriptorFromQueue, 2)     \
+                                                                                                                    macro(readableByteStreamControllerShiftPendingDescriptor, readableByteStreamInternalsReadableByteStreamControllerShiftPendingDescriptor, 1)   \
+                                                                                                                        macro(readableByteStreamControllerInvalidateBYOBRequest, readableByteStreamInternalsReadableByteStreamControllerInvalidateBYOBRequest, 1) \
+                                                                                                                            macro(readableByteStreamControllerCommitDescriptor, readableByteStreamInternalsReadableByteStreamControllerCommitDescriptor, 2)       \
+                                                                                                                                macro(readableByteStreamControllerConvertDescriptor, readableByteStreamInternalsReadableByteStreamControllerConvertDescriptor, 1) \
+                                                                                                                                    macro(readableStreamFulfillReadIntoRequest, readableByteStreamInternalsReadableStreamFulfillReadIntoRequest, 3)               \
+                                                                                                                                        macro(readableStreamBYOBReaderRead, readableByteStreamInternalsReadableStreamBYOBReaderRead, 2)                           \
+                                                                                                                                            macro(readableByteStreamControllerPullInto, readableByteStreamInternalsReadableByteStreamControllerPullInto, 2)       \
+                                                                                                                                                macro(readableStreamAddReadIntoRequest, readableByteStreamInternalsReadableStreamAddReadIntoRequest, 1)
 
 /* ReadableStream */
 extern const char* const s_readableStreamInitializeReadableStreamCode;
@@ -674,22 +674,22 @@ extern const int s_readableStreamLockedCodeLength;
 extern const JSC::ConstructAbility s_readableStreamLockedCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamLockedCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLESTREAM_BUILTIN_DATA(macro) \
-    macro(initializeReadableStream, readableStreamInitializeReadableStream, 2) \
-    macro(readableStreamToArray, readableStreamReadableStreamToArray, 1) \
-    macro(readableStreamToText, readableStreamReadableStreamToText, 1) \
-    macro(readableStreamToJSON, readableStreamReadableStreamToJSON, 1) \
-    macro(readableStreamToBlob, readableStreamReadableStreamToBlob, 1) \
-    macro(readableStreamToArrayPublic, readableStreamReadableStreamToArrayPublic, 1) \
-    macro(consumeReadableStream, readableStreamConsumeReadableStream, 3) \
-    macro(createEmptyReadableStream, readableStreamCreateEmptyReadableStream, 0) \
-    macro(createNativeReadableStream, readableStreamCreateNativeReadableStream, 3) \
-    macro(cancel, readableStreamCancel, 1) \
-    macro(getReader, readableStreamGetReader, 1) \
-    macro(pipeThrough, readableStreamPipeThrough, 2) \
-    macro(pipeTo, readableStreamPipeTo, 1) \
-    macro(tee, readableStreamTee, 0) \
-    macro(locked, readableStreamLocked, 0) \
+#define WEBCORE_FOREACH_READABLESTREAM_BUILTIN_DATA(macro)                                                         \
+    macro(initializeReadableStream, readableStreamInitializeReadableStream, 2)                                     \
+        macro(readableStreamToArray, readableStreamReadableStreamToArray, 1)                                       \
+            macro(readableStreamToText, readableStreamReadableStreamToText, 1)                                     \
+                macro(readableStreamToJSON, readableStreamReadableStreamToJSON, 1)                                 \
+                    macro(readableStreamToBlob, readableStreamReadableStreamToBlob, 1)                             \
+                        macro(readableStreamToArrayPublic, readableStreamReadableStreamToArrayPublic, 1)           \
+                            macro(consumeReadableStream, readableStreamConsumeReadableStream, 3)                   \
+                                macro(createEmptyReadableStream, readableStreamCreateEmptyReadableStream, 0)       \
+                                    macro(createNativeReadableStream, readableStreamCreateNativeReadableStream, 3) \
+                                        macro(cancel, readableStreamCancel, 1)                                     \
+                                            macro(getReader, readableStreamGetReader, 1)                           \
+                                                macro(pipeThrough, readableStreamPipeThrough, 2)                   \
+                                                    macro(pipeTo, readableStreamPipeTo, 1)                         \
+                                                        macro(tee, readableStreamTee, 0)                           \
+                                                            macro(locked, readableStreamLocked, 0)
 
 /* ReadableStreamBYOBReader */
 extern const char* const s_readableStreamBYOBReaderInitializeReadableStreamBYOBReaderCode;
@@ -713,12 +713,12 @@ extern const int s_readableStreamBYOBReaderClosedCodeLength;
 extern const JSC::ConstructAbility s_readableStreamBYOBReaderClosedCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamBYOBReaderClosedCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLESTREAMBYOBREADER_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_READABLESTREAMBYOBREADER_BUILTIN_DATA(macro)                                         \
     macro(initializeReadableStreamBYOBReader, readableStreamBYOBReaderInitializeReadableStreamBYOBReader, 1) \
-    macro(cancel, readableStreamBYOBReaderCancel, 1) \
-    macro(read, readableStreamBYOBReaderRead, 1) \
-    macro(releaseLock, readableStreamBYOBReaderReleaseLock, 0) \
-    macro(closed, readableStreamBYOBReaderClosed, 0) \
+        macro(cancel, readableStreamBYOBReaderCancel, 1)                                                     \
+            macro(read, readableStreamBYOBReaderRead, 1)                                                     \
+                macro(releaseLock, readableStreamBYOBReaderReleaseLock, 0)                                   \
+                    macro(closed, readableStreamBYOBReaderClosed, 0)
 
 /* ReadableStreamBYOBRequest */
 extern const char* const s_readableStreamBYOBRequestInitializeReadableStreamBYOBRequestCode;
@@ -738,11 +738,11 @@ extern const int s_readableStreamBYOBRequestViewCodeLength;
 extern const JSC::ConstructAbility s_readableStreamBYOBRequestViewCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamBYOBRequestViewCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLESTREAMBYOBREQUEST_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_READABLESTREAMBYOBREQUEST_BUILTIN_DATA(macro)                                           \
     macro(initializeReadableStreamBYOBRequest, readableStreamBYOBRequestInitializeReadableStreamBYOBRequest, 2) \
-    macro(respond, readableStreamBYOBRequestRespond, 1) \
-    macro(respondWithNewView, readableStreamBYOBRequestRespondWithNewView, 1) \
-    macro(view, readableStreamBYOBRequestView, 0) \
+        macro(respond, readableStreamBYOBRequestRespond, 1)                                                     \
+            macro(respondWithNewView, readableStreamBYOBRequestRespondWithNewView, 1)                           \
+                macro(view, readableStreamBYOBRequestView, 0)
 
 /* ReadableStreamDefaultController */
 extern const char* const s_readableStreamDefaultControllerInitializeReadableStreamDefaultControllerCode;
@@ -766,12 +766,12 @@ extern const int s_readableStreamDefaultControllerDesiredSizeCodeLength;
 extern const JSC::ConstructAbility s_readableStreamDefaultControllerDesiredSizeCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamDefaultControllerDesiredSizeCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLESTREAMDEFAULTCONTROLLER_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_READABLESTREAMDEFAULTCONTROLLER_BUILTIN_DATA(macro)                                                       \
     macro(initializeReadableStreamDefaultController, readableStreamDefaultControllerInitializeReadableStreamDefaultController, 4) \
-    macro(enqueue, readableStreamDefaultControllerEnqueue, 1) \
-    macro(error, readableStreamDefaultControllerError, 1) \
-    macro(close, readableStreamDefaultControllerClose, 0) \
-    macro(desiredSize, readableStreamDefaultControllerDesiredSize, 0) \
+        macro(enqueue, readableStreamDefaultControllerEnqueue, 1)                                                                 \
+            macro(error, readableStreamDefaultControllerError, 1)                                                                 \
+                macro(close, readableStreamDefaultControllerClose, 0)                                                             \
+                    macro(desiredSize, readableStreamDefaultControllerDesiredSize, 0)
 
 /* ReadableStreamDefaultReader */
 extern const char* const s_readableStreamDefaultReaderInitializeReadableStreamDefaultReaderCode;
@@ -799,13 +799,13 @@ extern const int s_readableStreamDefaultReaderClosedCodeLength;
 extern const JSC::ConstructAbility s_readableStreamDefaultReaderClosedCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamDefaultReaderClosedCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLESTREAMDEFAULTREADER_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_READABLESTREAMDEFAULTREADER_BUILTIN_DATA(macro)                                               \
     macro(initializeReadableStreamDefaultReader, readableStreamDefaultReaderInitializeReadableStreamDefaultReader, 1) \
-    macro(cancel, readableStreamDefaultReaderCancel, 1) \
-    macro(readMany, readableStreamDefaultReaderReadMany, 0) \
-    macro(read, readableStreamDefaultReaderRead, 0) \
-    macro(releaseLock, readableStreamDefaultReaderReleaseLock, 0) \
-    macro(closed, readableStreamDefaultReaderClosed, 0) \
+        macro(cancel, readableStreamDefaultReaderCancel, 1)                                                           \
+            macro(readMany, readableStreamDefaultReaderReadMany, 0)                                                   \
+                macro(read, readableStreamDefaultReaderRead, 0)                                                       \
+                    macro(releaseLock, readableStreamDefaultReaderReleaseLock, 0)                                     \
+                        macro(closed, readableStreamDefaultReaderClosed, 0)
 
 /* ReadableStreamInternals */
 extern const char* const s_readableStreamInternalsReadableStreamReaderGenericInitializeCode;
@@ -1021,60 +1021,60 @@ extern const int s_readableStreamInternalsLazyLoadStreamCodeLength;
 extern const JSC::ConstructAbility s_readableStreamInternalsLazyLoadStreamCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeConstructorKind;
 
-#define WEBCORE_FOREACH_READABLESTREAMINTERNALS_BUILTIN_DATA(macro) \
-    macro(readableStreamReaderGenericInitialize, readableStreamInternalsReadableStreamReaderGenericInitialize, 2) \
-    macro(privateInitializeReadableStreamDefaultController, readableStreamInternalsPrivateInitializeReadableStreamDefaultController, 4) \
-    macro(readableStreamDefaultControllerError, readableStreamInternalsReadableStreamDefaultControllerError, 2) \
-    macro(readableStreamPipeTo, readableStreamInternalsReadableStreamPipeTo, 2) \
-    macro(acquireReadableStreamDefaultReader, readableStreamInternalsAcquireReadableStreamDefaultReader, 1) \
-    macro(setupReadableStreamDefaultController, readableStreamInternalsSetupReadableStreamDefaultController, 7) \
-    macro(createReadableStreamController, readableStreamInternalsCreateReadableStreamController, 3) \
-    macro(readableStreamDefaultControllerStart, readableStreamInternalsReadableStreamDefaultControllerStart, 1) \
-    macro(readableStreamPipeToWritableStream, readableStreamInternalsReadableStreamPipeToWritableStream, 6) \
-    macro(pipeToLoop, readableStreamInternalsPipeToLoop, 1) \
-    macro(pipeToDoReadWrite, readableStreamInternalsPipeToDoReadWrite, 1) \
-    macro(pipeToErrorsMustBePropagatedForward, readableStreamInternalsPipeToErrorsMustBePropagatedForward, 1) \
-    macro(pipeToErrorsMustBePropagatedBackward, readableStreamInternalsPipeToErrorsMustBePropagatedBackward, 1) \
-    macro(pipeToClosingMustBePropagatedForward, readableStreamInternalsPipeToClosingMustBePropagatedForward, 1) \
-    macro(pipeToClosingMustBePropagatedBackward, readableStreamInternalsPipeToClosingMustBePropagatedBackward, 1) \
-    macro(pipeToShutdownWithAction, readableStreamInternalsPipeToShutdownWithAction, 2) \
-    macro(pipeToShutdown, readableStreamInternalsPipeToShutdown, 1) \
-    macro(pipeToFinalize, readableStreamInternalsPipeToFinalize, 1) \
-    macro(readableStreamTee, readableStreamInternalsReadableStreamTee, 2) \
-    macro(readableStreamTeePullFunction, readableStreamInternalsReadableStreamTeePullFunction, 3) \
-    macro(readableStreamTeeBranch1CancelFunction, readableStreamInternalsReadableStreamTeeBranch1CancelFunction, 2) \
-    macro(readableStreamTeeBranch2CancelFunction, readableStreamInternalsReadableStreamTeeBranch2CancelFunction, 2) \
-    macro(isReadableStream, readableStreamInternalsIsReadableStream, 1) \
-    macro(isReadableStreamDefaultReader, readableStreamInternalsIsReadableStreamDefaultReader, 1) \
-    macro(isReadableStreamDefaultController, readableStreamInternalsIsReadableStreamDefaultController, 1) \
-    macro(assignDirectStream, readableStreamInternalsAssignDirectStream, 0) \
-    macro(handleDirectStreamError, readableStreamInternalsHandleDirectStreamError, 1) \
-    macro(handleDirectStreamErrorReject, readableStreamInternalsHandleDirectStreamErrorReject, 1) \
-    macro(onPullDirectStream, readableStreamInternalsOnPullDirectStream, 1) \
-    macro(noopDoneFunction, readableStreamInternalsNoopDoneFunction, 0) \
-    macro(onReadableStreamDirectControllerClosed, readableStreamInternalsOnReadableStreamDirectControllerClosed, 1) \
-    macro(onCloseDirectStream, readableStreamInternalsOnCloseDirectStream, 1) \
-    macro(onDrainDirectStream, readableStreamInternalsOnDrainDirectStream, 0) \
-    macro(initializeArrayBufferStream, readableStreamInternalsInitializeArrayBufferStream, 2) \
-    macro(readableStreamError, readableStreamInternalsReadableStreamError, 2) \
-    macro(readableStreamDefaultControllerShouldCallPull, readableStreamInternalsReadableStreamDefaultControllerShouldCallPull, 1) \
-    macro(readableStreamDefaultControllerCallPullIfNeeded, readableStreamInternalsReadableStreamDefaultControllerCallPullIfNeeded, 1) \
-    macro(isReadableStreamLocked, readableStreamInternalsIsReadableStreamLocked, 1) \
-    macro(readableStreamDefaultControllerGetDesiredSize, readableStreamInternalsReadableStreamDefaultControllerGetDesiredSize, 1) \
-    macro(readableStreamReaderGenericCancel, readableStreamInternalsReadableStreamReaderGenericCancel, 2) \
-    macro(readableStreamCancel, readableStreamInternalsReadableStreamCancel, 2) \
-    macro(readableStreamDefaultControllerCancel, readableStreamInternalsReadableStreamDefaultControllerCancel, 2) \
-    macro(readableStreamDefaultControllerPull, readableStreamInternalsReadableStreamDefaultControllerPull, 1) \
-    macro(readableStreamDefaultControllerClose, readableStreamInternalsReadableStreamDefaultControllerClose, 1) \
-    macro(readableStreamClose, readableStreamInternalsReadableStreamClose, 1) \
-    macro(readableStreamFulfillReadRequest, readableStreamInternalsReadableStreamFulfillReadRequest, 3) \
-    macro(readableStreamDefaultControllerEnqueue, readableStreamInternalsReadableStreamDefaultControllerEnqueue, 2) \
-    macro(readableStreamDefaultReaderRead, readableStreamInternalsReadableStreamDefaultReaderRead, 1) \
-    macro(readableStreamAddReadRequest, readableStreamInternalsReadableStreamAddReadRequest, 1) \
-    macro(isReadableStreamDisturbed, readableStreamInternalsIsReadableStreamDisturbed, 1) \
-    macro(readableStreamReaderGenericRelease, readableStreamInternalsReadableStreamReaderGenericRelease, 1) \
-    macro(readableStreamDefaultControllerCanCloseOrEnqueue, readableStreamInternalsReadableStreamDefaultControllerCanCloseOrEnqueue, 1) \
-    macro(lazyLoadStream, readableStreamInternalsLazyLoadStream, 2) \
+#define WEBCORE_FOREACH_READABLESTREAMINTERNALS_BUILTIN_DATA(macro)                                                                                                                                                                                                                                                                                 \
+    macro(readableStreamReaderGenericInitialize, readableStreamInternalsReadableStreamReaderGenericInitialize, 2)                                                                                                                                                                                                                                   \
+        macro(privateInitializeReadableStreamDefaultController, readableStreamInternalsPrivateInitializeReadableStreamDefaultController, 4)                                                                                                                                                                                                         \
+            macro(readableStreamDefaultControllerError, readableStreamInternalsReadableStreamDefaultControllerError, 2)                                                                                                                                                                                                                             \
+                macro(readableStreamPipeTo, readableStreamInternalsReadableStreamPipeTo, 2)                                                                                                                                                                                                                                                         \
+                    macro(acquireReadableStreamDefaultReader, readableStreamInternalsAcquireReadableStreamDefaultReader, 1)                                                                                                                                                                                                                         \
+                        macro(setupReadableStreamDefaultController, readableStreamInternalsSetupReadableStreamDefaultController, 7)                                                                                                                                                                                                                 \
+                            macro(createReadableStreamController, readableStreamInternalsCreateReadableStreamController, 3)                                                                                                                                                                                                                         \
+                                macro(readableStreamDefaultControllerStart, readableStreamInternalsReadableStreamDefaultControllerStart, 1)                                                                                                                                                                                                         \
+                                    macro(readableStreamPipeToWritableStream, readableStreamInternalsReadableStreamPipeToWritableStream, 6)                                                                                                                                                                                                         \
+                                        macro(pipeToLoop, readableStreamInternalsPipeToLoop, 1)                                                                                                                                                                                                                                                     \
+                                            macro(pipeToDoReadWrite, readableStreamInternalsPipeToDoReadWrite, 1)                                                                                                                                                                                                                                   \
+                                                macro(pipeToErrorsMustBePropagatedForward, readableStreamInternalsPipeToErrorsMustBePropagatedForward, 1)                                                                                                                                                                                           \
+                                                    macro(pipeToErrorsMustBePropagatedBackward, readableStreamInternalsPipeToErrorsMustBePropagatedBackward, 1)                                                                                                                                                                                     \
+                                                        macro(pipeToClosingMustBePropagatedForward, readableStreamInternalsPipeToClosingMustBePropagatedForward, 1)                                                                                                                                                                                 \
+                                                            macro(pipeToClosingMustBePropagatedBackward, readableStreamInternalsPipeToClosingMustBePropagatedBackward, 1)                                                                                                                                                                           \
+                                                                macro(pipeToShutdownWithAction, readableStreamInternalsPipeToShutdownWithAction, 2)                                                                                                                                                                                                 \
+                                                                    macro(pipeToShutdown, readableStreamInternalsPipeToShutdown, 1)                                                                                                                                                                                                                 \
+                                                                        macro(pipeToFinalize, readableStreamInternalsPipeToFinalize, 1)                                                                                                                                                                                                             \
+                                                                            macro(readableStreamTee, readableStreamInternalsReadableStreamTee, 2)                                                                                                                                                                                                   \
+                                                                                macro(readableStreamTeePullFunction, readableStreamInternalsReadableStreamTeePullFunction, 3)                                                                                                                                                                       \
+                                                                                    macro(readableStreamTeeBranch1CancelFunction, readableStreamInternalsReadableStreamTeeBranch1CancelFunction, 2)                                                                                                                                                 \
+                                                                                        macro(readableStreamTeeBranch2CancelFunction, readableStreamInternalsReadableStreamTeeBranch2CancelFunction, 2)                                                                                                                                             \
+                                                                                            macro(isReadableStream, readableStreamInternalsIsReadableStream, 1)                                                                                                                                                                                     \
+                                                                                                macro(isReadableStreamDefaultReader, readableStreamInternalsIsReadableStreamDefaultReader, 1)                                                                                                                                                       \
+                                                                                                    macro(isReadableStreamDefaultController, readableStreamInternalsIsReadableStreamDefaultController, 1)                                                                                                                                           \
+                                                                                                        macro(assignToStream, readableStreamInternalsAssignDirectStream, 0)                                                                                                                                                                         \
+                                                                                                            macro(handleDirectStreamError, readableStreamInternalsHandleDirectStreamError, 1)                                                                                                                                                       \
+                                                                                                                macro(handleDirectStreamErrorReject, readableStreamInternalsHandleDirectStreamErrorReject, 1)                                                                                                                                       \
+                                                                                                                    macro(onPullDirectStream, readableStreamInternalsOnPullDirectStream, 1)                                                                                                                                                         \
+                                                                                                                        macro(noopDoneFunction, readableStreamInternalsNoopDoneFunction, 0)                                                                                                                                                         \
+                                                                                                                            macro(onReadableStreamDirectControllerClosed, readableStreamInternalsOnReadableStreamDirectControllerClosed, 1)                                                                                                         \
+                                                                                                                                macro(onCloseDirectStream, readableStreamInternalsOnCloseDirectStream, 1)                                                                                                                                           \
+                                                                                                                                    macro(onDrainDirectStream, readableStreamInternalsOnDrainDirectStream, 0)                                                                                                                                       \
+                                                                                                                                        macro(initializeArrayBufferStream, readableStreamInternalsInitializeArrayBufferStream, 2)                                                                                                                   \
+                                                                                                                                            macro(readableStreamError, readableStreamInternalsReadableStreamError, 2)                                                                                                                               \
+                                                                                                                                                macro(readableStreamDefaultControllerShouldCallPull, readableStreamInternalsReadableStreamDefaultControllerShouldCallPull, 1)                                                                       \
+                                                                                                                                                    macro(readableStreamDefaultControllerCallPullIfNeeded, readableStreamInternalsReadableStreamDefaultControllerCallPullIfNeeded, 1)                                                               \
+                                                                                                                                                        macro(isReadableStreamLocked, readableStreamInternalsIsReadableStreamLocked, 1)                                                                                                             \
+                                                                                                                                                            macro(readableStreamDefaultControllerGetDesiredSize, readableStreamInternalsReadableStreamDefaultControllerGetDesiredSize, 1)                                                           \
+                                                                                                                                                                macro(readableStreamReaderGenericCancel, readableStreamInternalsReadableStreamReaderGenericCancel, 2)                                                                               \
+                                                                                                                                                                    macro(readableStreamCancel, readableStreamInternalsReadableStreamCancel, 2)                                                                                                     \
+                                                                                                                                                                        macro(readableStreamDefaultControllerCancel, readableStreamInternalsReadableStreamDefaultControllerCancel, 2)                                                               \
+                                                                                                                                                                            macro(readableStreamDefaultControllerPull, readableStreamInternalsReadableStreamDefaultControllerPull, 1)                                                               \
+                                                                                                                                                                                macro(readableStreamDefaultControllerClose, readableStreamInternalsReadableStreamDefaultControllerClose, 1)                                                         \
+                                                                                                                                                                                    macro(readableStreamClose, readableStreamInternalsReadableStreamClose, 1)                                                                                       \
+                                                                                                                                                                                        macro(readableStreamFulfillReadRequest, readableStreamInternalsReadableStreamFulfillReadRequest, 3)                                                         \
+                                                                                                                                                                                            macro(readableStreamDefaultControllerEnqueue, readableStreamInternalsReadableStreamDefaultControllerEnqueue, 2)                                         \
+                                                                                                                                                                                                macro(readableStreamDefaultReaderRead, readableStreamInternalsReadableStreamDefaultReaderRead, 1)                                                   \
+                                                                                                                                                                                                    macro(readableStreamAddReadRequest, readableStreamInternalsReadableStreamAddReadRequest, 1)                                                     \
+                                                                                                                                                                                                        macro(isReadableStreamDisturbed, readableStreamInternalsIsReadableStreamDisturbed, 1)                                                       \
+                                                                                                                                                                                                            macro(readableStreamReaderGenericRelease, readableStreamInternalsReadableStreamReaderGenericRelease, 1)                                 \
+                                                                                                                                                                                                                macro(readableStreamDefaultControllerCanCloseOrEnqueue, readableStreamInternalsReadableStreamDefaultControllerCanCloseOrEnqueue, 1) \
+                                                                                                                                                                                                                    macro(lazyLoadStream, readableStreamInternalsLazyLoadStream, 2)
 
 /* StreamInternals */
 extern const char* const s_streamInternalsMarkPromiseAsHandledCode;
@@ -1154,26 +1154,26 @@ extern const int s_streamInternalsToDictionaryCodeLength;
 extern const JSC::ConstructAbility s_streamInternalsToDictionaryCodeConstructAbility;
 extern const JSC::ConstructorKind s_streamInternalsToDictionaryCodeConstructorKind;
 
-#define WEBCORE_FOREACH_STREAMINTERNALS_BUILTIN_DATA(macro) \
-    macro(markPromiseAsHandled, streamInternalsMarkPromiseAsHandled, 1) \
-    macro(shieldingPromiseResolve, streamInternalsShieldingPromiseResolve, 1) \
-    macro(promiseInvokeOrNoopMethodNoCatch, streamInternalsPromiseInvokeOrNoopMethodNoCatch, 3) \
-    macro(promiseInvokeOrNoopNoCatch, streamInternalsPromiseInvokeOrNoopNoCatch, 3) \
-    macro(promiseInvokeOrNoopMethod, streamInternalsPromiseInvokeOrNoopMethod, 3) \
-    macro(promiseInvokeOrNoop, streamInternalsPromiseInvokeOrNoop, 3) \
-    macro(promiseInvokeOrFallbackOrNoop, streamInternalsPromiseInvokeOrFallbackOrNoop, 5) \
-    macro(validateAndNormalizeQueuingStrategy, streamInternalsValidateAndNormalizeQueuingStrategy, 2) \
-    macro(createFIFO, streamInternalsCreateFIFO, 0) \
-    macro(newQueue, streamInternalsNewQueue, 0) \
-    macro(dequeueValue, streamInternalsDequeueValue, 1) \
-    macro(enqueueValueWithSize, streamInternalsEnqueueValueWithSize, 3) \
-    macro(peekQueueValue, streamInternalsPeekQueueValue, 1) \
-    macro(resetQueue, streamInternalsResetQueue, 1) \
-    macro(extractSizeAlgorithm, streamInternalsExtractSizeAlgorithm, 1) \
-    macro(extractHighWaterMark, streamInternalsExtractHighWaterMark, 2) \
-    macro(extractHighWaterMarkFromQueuingStrategyInit, streamInternalsExtractHighWaterMarkFromQueuingStrategyInit, 1) \
-    macro(createFulfilledPromise, streamInternalsCreateFulfilledPromise, 1) \
-    macro(toDictionary, streamInternalsToDictionary, 3) \
+#define WEBCORE_FOREACH_STREAMINTERNALS_BUILTIN_DATA(macro)                                                                                                                           \
+    macro(markPromiseAsHandled, streamInternalsMarkPromiseAsHandled, 1)                                                                                                               \
+        macro(shieldingPromiseResolve, streamInternalsShieldingPromiseResolve, 1)                                                                                                     \
+            macro(promiseInvokeOrNoopMethodNoCatch, streamInternalsPromiseInvokeOrNoopMethodNoCatch, 3)                                                                               \
+                macro(promiseInvokeOrNoopNoCatch, streamInternalsPromiseInvokeOrNoopNoCatch, 3)                                                                                       \
+                    macro(promiseInvokeOrNoopMethod, streamInternalsPromiseInvokeOrNoopMethod, 3)                                                                                     \
+                        macro(promiseInvokeOrNoop, streamInternalsPromiseInvokeOrNoop, 3)                                                                                             \
+                            macro(promiseInvokeOrFallbackOrNoop, streamInternalsPromiseInvokeOrFallbackOrNoop, 5)                                                                     \
+                                macro(validateAndNormalizeQueuingStrategy, streamInternalsValidateAndNormalizeQueuingStrategy, 2)                                                     \
+                                    macro(createFIFO, streamInternalsCreateFIFO, 0)                                                                                                   \
+                                        macro(newQueue, streamInternalsNewQueue, 0)                                                                                                   \
+                                            macro(dequeueValue, streamInternalsDequeueValue, 1)                                                                                       \
+                                                macro(enqueueValueWithSize, streamInternalsEnqueueValueWithSize, 3)                                                                   \
+                                                    macro(peekQueueValue, streamInternalsPeekQueueValue, 1)                                                                           \
+                                                        macro(resetQueue, streamInternalsResetQueue, 1)                                                                               \
+                                                            macro(extractSizeAlgorithm, streamInternalsExtractSizeAlgorithm, 1)                                                       \
+                                                                macro(extractHighWaterMark, streamInternalsExtractHighWaterMark, 2)                                                   \
+                                                                    macro(extractHighWaterMarkFromQueuingStrategyInit, streamInternalsExtractHighWaterMarkFromQueuingStrategyInit, 1) \
+                                                                        macro(createFulfilledPromise, streamInternalsCreateFulfilledPromise, 1)                                       \
+                                                                            macro(toDictionary, streamInternalsToDictionary, 3)
 
 /* TransformStream */
 extern const char* const s_transformStreamInitializeTransformStreamCode;
@@ -1189,10 +1189,10 @@ extern const int s_transformStreamWritableCodeLength;
 extern const JSC::ConstructAbility s_transformStreamWritableCodeConstructAbility;
 extern const JSC::ConstructorKind s_transformStreamWritableCodeConstructorKind;
 
-#define WEBCORE_FOREACH_TRANSFORMSTREAM_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_TRANSFORMSTREAM_BUILTIN_DATA(macro)                       \
     macro(initializeTransformStream, transformStreamInitializeTransformStream, 0) \
-    macro(readable, transformStreamReadable, 0) \
-    macro(writable, transformStreamWritable, 0) \
+        macro(readable, transformStreamReadable, 0)                               \
+            macro(writable, transformStreamWritable, 0)
 
 /* TransformStreamDefaultController */
 extern const char* const s_transformStreamDefaultControllerInitializeTransformStreamDefaultControllerCode;
@@ -1216,12 +1216,12 @@ extern const int s_transformStreamDefaultControllerTerminateCodeLength;
 extern const JSC::ConstructAbility s_transformStreamDefaultControllerTerminateCodeConstructAbility;
 extern const JSC::ConstructorKind s_transformStreamDefaultControllerTerminateCodeConstructorKind;
 
-#define WEBCORE_FOREACH_TRANSFORMSTREAMDEFAULTCONTROLLER_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_TRANSFORMSTREAMDEFAULTCONTROLLER_BUILTIN_DATA(macro)                                                         \
     macro(initializeTransformStreamDefaultController, transformStreamDefaultControllerInitializeTransformStreamDefaultController, 0) \
-    macro(desiredSize, transformStreamDefaultControllerDesiredSize, 0) \
-    macro(enqueue, transformStreamDefaultControllerEnqueue, 1) \
-    macro(error, transformStreamDefaultControllerError, 1) \
-    macro(terminate, transformStreamDefaultControllerTerminate, 0) \
+        macro(desiredSize, transformStreamDefaultControllerDesiredSize, 0)                                                           \
+            macro(enqueue, transformStreamDefaultControllerEnqueue, 1)                                                               \
+                macro(error, transformStreamDefaultControllerError, 1)                                                               \
+                    macro(terminate, transformStreamDefaultControllerTerminate, 0)
 
 /* TransformStreamInternals */
 extern const char* const s_transformStreamInternalsIsTransformStreamCode;
@@ -1297,25 +1297,25 @@ extern const int s_transformStreamInternalsTransformStreamDefaultSourcePullAlgor
 extern const JSC::ConstructAbility s_transformStreamInternalsTransformStreamDefaultSourcePullAlgorithmCodeConstructAbility;
 extern const JSC::ConstructorKind s_transformStreamInternalsTransformStreamDefaultSourcePullAlgorithmCodeConstructorKind;
 
-#define WEBCORE_FOREACH_TRANSFORMSTREAMINTERNALS_BUILTIN_DATA(macro) \
-    macro(isTransformStream, transformStreamInternalsIsTransformStream, 1) \
-    macro(isTransformStreamDefaultController, transformStreamInternalsIsTransformStreamDefaultController, 1) \
-    macro(createTransformStream, transformStreamInternalsCreateTransformStream, 7) \
-    macro(initializeTransformStream, transformStreamInternalsInitializeTransformStream, 6) \
-    macro(transformStreamError, transformStreamInternalsTransformStreamError, 2) \
-    macro(transformStreamErrorWritableAndUnblockWrite, transformStreamInternalsTransformStreamErrorWritableAndUnblockWrite, 2) \
-    macro(transformStreamSetBackpressure, transformStreamInternalsTransformStreamSetBackpressure, 2) \
-    macro(setUpTransformStreamDefaultController, transformStreamInternalsSetUpTransformStreamDefaultController, 4) \
-    macro(setUpTransformStreamDefaultControllerFromTransformer, transformStreamInternalsSetUpTransformStreamDefaultControllerFromTransformer, 3) \
-    macro(transformStreamDefaultControllerClearAlgorithms, transformStreamInternalsTransformStreamDefaultControllerClearAlgorithms, 1) \
-    macro(transformStreamDefaultControllerEnqueue, transformStreamInternalsTransformStreamDefaultControllerEnqueue, 2) \
-    macro(transformStreamDefaultControllerError, transformStreamInternalsTransformStreamDefaultControllerError, 2) \
-    macro(transformStreamDefaultControllerPerformTransform, transformStreamInternalsTransformStreamDefaultControllerPerformTransform, 2) \
-    macro(transformStreamDefaultControllerTerminate, transformStreamInternalsTransformStreamDefaultControllerTerminate, 1) \
-    macro(transformStreamDefaultSinkWriteAlgorithm, transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithm, 2) \
-    macro(transformStreamDefaultSinkAbortAlgorithm, transformStreamInternalsTransformStreamDefaultSinkAbortAlgorithm, 2) \
-    macro(transformStreamDefaultSinkCloseAlgorithm, transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithm, 1) \
-    macro(transformStreamDefaultSourcePullAlgorithm, transformStreamInternalsTransformStreamDefaultSourcePullAlgorithm, 1) \
+#define WEBCORE_FOREACH_TRANSFORMSTREAMINTERNALS_BUILTIN_DATA(macro)                                                                                                                     \
+    macro(isTransformStream, transformStreamInternalsIsTransformStream, 1)                                                                                                               \
+        macro(isTransformStreamDefaultController, transformStreamInternalsIsTransformStreamDefaultController, 1)                                                                         \
+            macro(createTransformStream, transformStreamInternalsCreateTransformStream, 7)                                                                                               \
+                macro(initializeTransformStream, transformStreamInternalsInitializeTransformStream, 6)                                                                                   \
+                    macro(transformStreamError, transformStreamInternalsTransformStreamError, 2)                                                                                         \
+                        macro(transformStreamErrorWritableAndUnblockWrite, transformStreamInternalsTransformStreamErrorWritableAndUnblockWrite, 2)                                       \
+                            macro(transformStreamSetBackpressure, transformStreamInternalsTransformStreamSetBackpressure, 2)                                                             \
+                                macro(setUpTransformStreamDefaultController, transformStreamInternalsSetUpTransformStreamDefaultController, 4)                                           \
+                                    macro(setUpTransformStreamDefaultControllerFromTransformer, transformStreamInternalsSetUpTransformStreamDefaultControllerFromTransformer, 3)         \
+                                        macro(transformStreamDefaultControllerClearAlgorithms, transformStreamInternalsTransformStreamDefaultControllerClearAlgorithms, 1)               \
+                                            macro(transformStreamDefaultControllerEnqueue, transformStreamInternalsTransformStreamDefaultControllerEnqueue, 2)                           \
+                                                macro(transformStreamDefaultControllerError, transformStreamInternalsTransformStreamDefaultControllerError, 2)                           \
+                                                    macro(transformStreamDefaultControllerPerformTransform, transformStreamInternalsTransformStreamDefaultControllerPerformTransform, 2) \
+                                                        macro(transformStreamDefaultControllerTerminate, transformStreamInternalsTransformStreamDefaultControllerTerminate, 1)           \
+                                                            macro(transformStreamDefaultSinkWriteAlgorithm, transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithm, 2)         \
+                                                                macro(transformStreamDefaultSinkAbortAlgorithm, transformStreamInternalsTransformStreamDefaultSinkAbortAlgorithm, 2)     \
+                                                                    macro(transformStreamDefaultSinkCloseAlgorithm, transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithm, 1) \
+                                                                        macro(transformStreamDefaultSourcePullAlgorithm, transformStreamInternalsTransformStreamDefaultSourcePullAlgorithm, 1)
 
 /* WritableStreamDefaultController */
 extern const char* const s_writableStreamDefaultControllerInitializeWritableStreamDefaultControllerCode;
@@ -1327,9 +1327,9 @@ extern const int s_writableStreamDefaultControllerErrorCodeLength;
 extern const JSC::ConstructAbility s_writableStreamDefaultControllerErrorCodeConstructAbility;
 extern const JSC::ConstructorKind s_writableStreamDefaultControllerErrorCodeConstructorKind;
 
-#define WEBCORE_FOREACH_WRITABLESTREAMDEFAULTCONTROLLER_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_WRITABLESTREAMDEFAULTCONTROLLER_BUILTIN_DATA(macro)                                                       \
     macro(initializeWritableStreamDefaultController, writableStreamDefaultControllerInitializeWritableStreamDefaultController, 0) \
-    macro(error, writableStreamDefaultControllerError, 1) \
+        macro(error, writableStreamDefaultControllerError, 1)
 
 /* WritableStreamDefaultWriter */
 extern const char* const s_writableStreamDefaultWriterInitializeWritableStreamDefaultWriterCode;
@@ -1365,15 +1365,15 @@ extern const int s_writableStreamDefaultWriterWriteCodeLength;
 extern const JSC::ConstructAbility s_writableStreamDefaultWriterWriteCodeConstructAbility;
 extern const JSC::ConstructorKind s_writableStreamDefaultWriterWriteCodeConstructorKind;
 
-#define WEBCORE_FOREACH_WRITABLESTREAMDEFAULTWRITER_BUILTIN_DATA(macro) \
+#define WEBCORE_FOREACH_WRITABLESTREAMDEFAULTWRITER_BUILTIN_DATA(macro)                                               \
     macro(initializeWritableStreamDefaultWriter, writableStreamDefaultWriterInitializeWritableStreamDefaultWriter, 1) \
-    macro(closed, writableStreamDefaultWriterClosed, 0) \
-    macro(desiredSize, writableStreamDefaultWriterDesiredSize, 0) \
-    macro(ready, writableStreamDefaultWriterReady, 0) \
-    macro(abort, writableStreamDefaultWriterAbort, 1) \
-    macro(close, writableStreamDefaultWriterClose, 0) \
-    macro(releaseLock, writableStreamDefaultWriterReleaseLock, 0) \
-    macro(write, writableStreamDefaultWriterWrite, 1) \
+        macro(closed, writableStreamDefaultWriterClosed, 0)                                                           \
+            macro(desiredSize, writableStreamDefaultWriterDesiredSize, 0)                                             \
+                macro(ready, writableStreamDefaultWriterReady, 0)                                                     \
+                    macro(abort, writableStreamDefaultWriterAbort, 1)                                                 \
+                        macro(close, writableStreamDefaultWriterClose, 0)                                             \
+                            macro(releaseLock, writableStreamDefaultWriterReleaseLock, 0)                             \
+                                macro(write, writableStreamDefaultWriterWrite, 1)
 
 /* WritableStreamInternals */
 extern const char* const s_writableStreamInternalsIsWritableStreamCode;
@@ -1573,650 +1573,650 @@ extern const int s_writableStreamInternalsWritableStreamDefaultControllerWriteCo
 extern const JSC::ConstructAbility s_writableStreamInternalsWritableStreamDefaultControllerWriteCodeConstructAbility;
 extern const JSC::ConstructorKind s_writableStreamInternalsWritableStreamDefaultControllerWriteCodeConstructorKind;
 
-#define WEBCORE_FOREACH_WRITABLESTREAMINTERNALS_BUILTIN_DATA(macro) \
-    macro(isWritableStream, writableStreamInternalsIsWritableStream, 1) \
-    macro(isWritableStreamDefaultWriter, writableStreamInternalsIsWritableStreamDefaultWriter, 1) \
-    macro(acquireWritableStreamDefaultWriter, writableStreamInternalsAcquireWritableStreamDefaultWriter, 1) \
-    macro(createWritableStream, writableStreamInternalsCreateWritableStream, 6) \
-    macro(createInternalWritableStreamFromUnderlyingSink, writableStreamInternalsCreateInternalWritableStreamFromUnderlyingSink, 2) \
-    macro(initializeWritableStreamSlots, writableStreamInternalsInitializeWritableStreamSlots, 2) \
-    macro(writableStreamCloseForBindings, writableStreamInternalsWritableStreamCloseForBindings, 1) \
-    macro(writableStreamAbortForBindings, writableStreamInternalsWritableStreamAbortForBindings, 2) \
-    macro(isWritableStreamLocked, writableStreamInternalsIsWritableStreamLocked, 1) \
-    macro(setUpWritableStreamDefaultWriter, writableStreamInternalsSetUpWritableStreamDefaultWriter, 2) \
-    macro(writableStreamAbort, writableStreamInternalsWritableStreamAbort, 2) \
-    macro(writableStreamClose, writableStreamInternalsWritableStreamClose, 1) \
-    macro(writableStreamAddWriteRequest, writableStreamInternalsWritableStreamAddWriteRequest, 1) \
-    macro(writableStreamCloseQueuedOrInFlight, writableStreamInternalsWritableStreamCloseQueuedOrInFlight, 1) \
-    macro(writableStreamDealWithRejection, writableStreamInternalsWritableStreamDealWithRejection, 2) \
-    macro(writableStreamFinishErroring, writableStreamInternalsWritableStreamFinishErroring, 1) \
-    macro(writableStreamFinishInFlightClose, writableStreamInternalsWritableStreamFinishInFlightClose, 1) \
-    macro(writableStreamFinishInFlightCloseWithError, writableStreamInternalsWritableStreamFinishInFlightCloseWithError, 2) \
-    macro(writableStreamFinishInFlightWrite, writableStreamInternalsWritableStreamFinishInFlightWrite, 1) \
-    macro(writableStreamFinishInFlightWriteWithError, writableStreamInternalsWritableStreamFinishInFlightWriteWithError, 2) \
-    macro(writableStreamHasOperationMarkedInFlight, writableStreamInternalsWritableStreamHasOperationMarkedInFlight, 1) \
-    macro(writableStreamMarkCloseRequestInFlight, writableStreamInternalsWritableStreamMarkCloseRequestInFlight, 1) \
-    macro(writableStreamMarkFirstWriteRequestInFlight, writableStreamInternalsWritableStreamMarkFirstWriteRequestInFlight, 1) \
-    macro(writableStreamRejectCloseAndClosedPromiseIfNeeded, writableStreamInternalsWritableStreamRejectCloseAndClosedPromiseIfNeeded, 1) \
-    macro(writableStreamStartErroring, writableStreamInternalsWritableStreamStartErroring, 2) \
-    macro(writableStreamUpdateBackpressure, writableStreamInternalsWritableStreamUpdateBackpressure, 2) \
-    macro(writableStreamDefaultWriterAbort, writableStreamInternalsWritableStreamDefaultWriterAbort, 2) \
-    macro(writableStreamDefaultWriterClose, writableStreamInternalsWritableStreamDefaultWriterClose, 1) \
-    macro(writableStreamDefaultWriterCloseWithErrorPropagation, writableStreamInternalsWritableStreamDefaultWriterCloseWithErrorPropagation, 1) \
-    macro(writableStreamDefaultWriterEnsureClosedPromiseRejected, writableStreamInternalsWritableStreamDefaultWriterEnsureClosedPromiseRejected, 2) \
-    macro(writableStreamDefaultWriterEnsureReadyPromiseRejected, writableStreamInternalsWritableStreamDefaultWriterEnsureReadyPromiseRejected, 2) \
-    macro(writableStreamDefaultWriterGetDesiredSize, writableStreamInternalsWritableStreamDefaultWriterGetDesiredSize, 1) \
-    macro(writableStreamDefaultWriterRelease, writableStreamInternalsWritableStreamDefaultWriterRelease, 1) \
-    macro(writableStreamDefaultWriterWrite, writableStreamInternalsWritableStreamDefaultWriterWrite, 2) \
-    macro(setUpWritableStreamDefaultController, writableStreamInternalsSetUpWritableStreamDefaultController, 8) \
-    macro(writableStreamDefaultControllerStart, writableStreamInternalsWritableStreamDefaultControllerStart, 1) \
-    macro(setUpWritableStreamDefaultControllerFromUnderlyingSink, writableStreamInternalsSetUpWritableStreamDefaultControllerFromUnderlyingSink, 5) \
-    macro(writableStreamDefaultControllerAdvanceQueueIfNeeded, writableStreamInternalsWritableStreamDefaultControllerAdvanceQueueIfNeeded, 1) \
-    macro(isCloseSentinel, writableStreamInternalsIsCloseSentinel, 0) \
-    macro(writableStreamDefaultControllerClearAlgorithms, writableStreamInternalsWritableStreamDefaultControllerClearAlgorithms, 1) \
-    macro(writableStreamDefaultControllerClose, writableStreamInternalsWritableStreamDefaultControllerClose, 1) \
-    macro(writableStreamDefaultControllerError, writableStreamInternalsWritableStreamDefaultControllerError, 2) \
-    macro(writableStreamDefaultControllerErrorIfNeeded, writableStreamInternalsWritableStreamDefaultControllerErrorIfNeeded, 2) \
-    macro(writableStreamDefaultControllerGetBackpressure, writableStreamInternalsWritableStreamDefaultControllerGetBackpressure, 1) \
-    macro(writableStreamDefaultControllerGetChunkSize, writableStreamInternalsWritableStreamDefaultControllerGetChunkSize, 2) \
-    macro(writableStreamDefaultControllerGetDesiredSize, writableStreamInternalsWritableStreamDefaultControllerGetDesiredSize, 1) \
-    macro(writableStreamDefaultControllerProcessClose, writableStreamInternalsWritableStreamDefaultControllerProcessClose, 1) \
-    macro(writableStreamDefaultControllerProcessWrite, writableStreamInternalsWritableStreamDefaultControllerProcessWrite, 2) \
-    macro(writableStreamDefaultControllerWrite, writableStreamInternalsWritableStreamDefaultControllerWrite, 3) \
+#define WEBCORE_FOREACH_WRITABLESTREAMINTERNALS_BUILTIN_DATA(macro)                                                                                                                                                                                                                                                       \
+    macro(isWritableStream, writableStreamInternalsIsWritableStream, 1)                                                                                                                                                                                                                                                   \
+        macro(isWritableStreamDefaultWriter, writableStreamInternalsIsWritableStreamDefaultWriter, 1)                                                                                                                                                                                                                     \
+            macro(acquireWritableStreamDefaultWriter, writableStreamInternalsAcquireWritableStreamDefaultWriter, 1)                                                                                                                                                                                                       \
+                macro(createWritableStream, writableStreamInternalsCreateWritableStream, 6)                                                                                                                                                                                                                               \
+                    macro(createInternalWritableStreamFromUnderlyingSink, writableStreamInternalsCreateInternalWritableStreamFromUnderlyingSink, 2)                                                                                                                                                                       \
+                        macro(initializeWritableStreamSlots, writableStreamInternalsInitializeWritableStreamSlots, 2)                                                                                                                                                                                                     \
+                            macro(writableStreamCloseForBindings, writableStreamInternalsWritableStreamCloseForBindings, 1)                                                                                                                                                                                               \
+                                macro(writableStreamAbortForBindings, writableStreamInternalsWritableStreamAbortForBindings, 2)                                                                                                                                                                                           \
+                                    macro(isWritableStreamLocked, writableStreamInternalsIsWritableStreamLocked, 1)                                                                                                                                                                                                       \
+                                        macro(setUpWritableStreamDefaultWriter, writableStreamInternalsSetUpWritableStreamDefaultWriter, 2)                                                                                                                                                                               \
+                                            macro(writableStreamAbort, writableStreamInternalsWritableStreamAbort, 2)                                                                                                                                                                                                     \
+                                                macro(writableStreamClose, writableStreamInternalsWritableStreamClose, 1)                                                                                                                                                                                                 \
+                                                    macro(writableStreamAddWriteRequest, writableStreamInternalsWritableStreamAddWriteRequest, 1)                                                                                                                                                                         \
+                                                        macro(writableStreamCloseQueuedOrInFlight, writableStreamInternalsWritableStreamCloseQueuedOrInFlight, 1)                                                                                                                                                         \
+                                                            macro(writableStreamDealWithRejection, writableStreamInternalsWritableStreamDealWithRejection, 2)                                                                                                                                                             \
+                                                                macro(writableStreamFinishErroring, writableStreamInternalsWritableStreamFinishErroring, 1)                                                                                                                                                               \
+                                                                    macro(writableStreamFinishInFlightClose, writableStreamInternalsWritableStreamFinishInFlightClose, 1)                                                                                                                                                 \
+                                                                        macro(writableStreamFinishInFlightCloseWithError, writableStreamInternalsWritableStreamFinishInFlightCloseWithError, 2)                                                                                                                           \
+                                                                            macro(writableStreamFinishInFlightWrite, writableStreamInternalsWritableStreamFinishInFlightWrite, 1)                                                                                                                                         \
+                                                                                macro(writableStreamFinishInFlightWriteWithError, writableStreamInternalsWritableStreamFinishInFlightWriteWithError, 2)                                                                                                                   \
+                                                                                    macro(writableStreamHasOperationMarkedInFlight, writableStreamInternalsWritableStreamHasOperationMarkedInFlight, 1)                                                                                                                   \
+                                                                                        macro(writableStreamMarkCloseRequestInFlight, writableStreamInternalsWritableStreamMarkCloseRequestInFlight, 1)                                                                                                                   \
+                                                                                            macro(writableStreamMarkFirstWriteRequestInFlight, writableStreamInternalsWritableStreamMarkFirstWriteRequestInFlight, 1)                                                                                                     \
+                                                                                                macro(writableStreamRejectCloseAndClosedPromiseIfNeeded, writableStreamInternalsWritableStreamRejectCloseAndClosedPromiseIfNeeded, 1)                                                                                     \
+                                                                                                    macro(writableStreamStartErroring, writableStreamInternalsWritableStreamStartErroring, 2)                                                                                                                             \
+                                                                                                        macro(writableStreamUpdateBackpressure, writableStreamInternalsWritableStreamUpdateBackpressure, 2)                                                                                                               \
+                                                                                                            macro(writableStreamDefaultWriterAbort, writableStreamInternalsWritableStreamDefaultWriterAbort, 2)                                                                                                           \
+                                                                                                                macro(writableStreamDefaultWriterClose, writableStreamInternalsWritableStreamDefaultWriterClose, 1)                                                                                                       \
+                                                                                                                    macro(writableStreamDefaultWriterCloseWithErrorPropagation, writableStreamInternalsWritableStreamDefaultWriterCloseWithErrorPropagation, 1)                                                           \
+                                                                                                                        macro(writableStreamDefaultWriterEnsureClosedPromiseRejected, writableStreamInternalsWritableStreamDefaultWriterEnsureClosedPromiseRejected, 2)                                                   \
+                                                                                                                            macro(writableStreamDefaultWriterEnsureReadyPromiseRejected, writableStreamInternalsWritableStreamDefaultWriterEnsureReadyPromiseRejected, 2)                                                 \
+                                                                                                                                macro(writableStreamDefaultWriterGetDesiredSize, writableStreamInternalsWritableStreamDefaultWriterGetDesiredSize, 1)                                                                     \
+                                                                                                                                    macro(writableStreamDefaultWriterRelease, writableStreamInternalsWritableStreamDefaultWriterRelease, 1)                                                                               \
+                                                                                                                                        macro(writableStreamDefaultWriterWrite, writableStreamInternalsWritableStreamDefaultWriterWrite, 2)                                                                               \
+                                                                                                                                            macro(setUpWritableStreamDefaultController, writableStreamInternalsSetUpWritableStreamDefaultController, 8)                                                                   \
+                                                                                                                                                macro(writableStreamDefaultControllerStart, writableStreamInternalsWritableStreamDefaultControllerStart, 1)                                                               \
+                                                                                                                                                    macro(setUpWritableStreamDefaultControllerFromUnderlyingSink, writableStreamInternalsSetUpWritableStreamDefaultControllerFromUnderlyingSink, 5)                       \
+                                                                                                                                                        macro(writableStreamDefaultControllerAdvanceQueueIfNeeded, writableStreamInternalsWritableStreamDefaultControllerAdvanceQueueIfNeeded, 1)                         \
+                                                                                                                                                            macro(isCloseSentinel, writableStreamInternalsIsCloseSentinel, 0)                                                                                             \
+                                                                                                                                                                macro(writableStreamDefaultControllerClearAlgorithms, writableStreamInternalsWritableStreamDefaultControllerClearAlgorithms, 1)                           \
+                                                                                                                                                                    macro(writableStreamDefaultControllerClose, writableStreamInternalsWritableStreamDefaultControllerClose, 1)                                           \
+                                                                                                                                                                        macro(writableStreamDefaultControllerError, writableStreamInternalsWritableStreamDefaultControllerError, 2)                                       \
+                                                                                                                                                                            macro(writableStreamDefaultControllerErrorIfNeeded, writableStreamInternalsWritableStreamDefaultControllerErrorIfNeeded, 2)                   \
+                                                                                                                                                                                macro(writableStreamDefaultControllerGetBackpressure, writableStreamInternalsWritableStreamDefaultControllerGetBackpressure, 1)           \
+                                                                                                                                                                                    macro(writableStreamDefaultControllerGetChunkSize, writableStreamInternalsWritableStreamDefaultControllerGetChunkSize, 2)             \
+                                                                                                                                                                                        macro(writableStreamDefaultControllerGetDesiredSize, writableStreamInternalsWritableStreamDefaultControllerGetDesiredSize, 1)     \
+                                                                                                                                                                                            macro(writableStreamDefaultControllerProcessClose, writableStreamInternalsWritableStreamDefaultControllerProcessClose, 1)     \
+                                                                                                                                                                                                macro(writableStreamDefaultControllerProcessWrite, writableStreamInternalsWritableStreamDefaultControllerProcessWrite, 2) \
+                                                                                                                                                                                                    macro(writableStreamDefaultControllerWrite, writableStreamInternalsWritableStreamDefaultControllerWrite, 3)
 
-#define WEBCORE_FOREACH_BUILTIN_CODE(macro) \
-    macro(writableStreamDefaultWriterAbortCode, abort, ASCIILiteral(), s_writableStreamDefaultWriterAbortCodeLength) \
-    macro(readableStreamInternalsAcquireReadableStreamDefaultReaderCode, acquireReadableStreamDefaultReader, ASCIILiteral(), s_readableStreamInternalsAcquireReadableStreamDefaultReaderCodeLength) \
-    macro(writableStreamInternalsAcquireWritableStreamDefaultWriterCode, acquireWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamInternalsAcquireWritableStreamDefaultWriterCodeLength) \
-    macro(jsBufferPrototypeAsciiSliceCode, asciiSlice, ASCIILiteral(), s_jsBufferPrototypeAsciiSliceCodeLength) \
-    macro(jsBufferPrototypeAsciiWriteCode, asciiWrite, ASCIILiteral(), s_jsBufferPrototypeAsciiWriteCodeLength) \
-    macro(readableStreamInternalsAssignDirectStreamCode, assignDirectStream, ASCIILiteral(), s_readableStreamInternalsAssignDirectStreamCodeLength) \
-    macro(jsBufferPrototypeBase64SliceCode, base64Slice, ASCIILiteral(), s_jsBufferPrototypeBase64SliceCodeLength) \
-    macro(jsBufferPrototypeBase64WriteCode, base64Write, ASCIILiteral(), s_jsBufferPrototypeBase64WriteCodeLength) \
-    macro(jsBufferPrototypeBase64urlSliceCode, base64urlSlice, ASCIILiteral(), s_jsBufferPrototypeBase64urlSliceCodeLength) \
-    macro(jsBufferPrototypeBase64urlWriteCode, base64urlWrite, ASCIILiteral(), s_jsBufferPrototypeBase64urlWriteCodeLength) \
-    macro(readableByteStreamControllerByobRequestCode, byobRequest, "get byobRequest"_s, s_readableByteStreamControllerByobRequestCodeLength) \
-    macro(readableStreamCancelCode, cancel, ASCIILiteral(), s_readableStreamCancelCodeLength) \
-    macro(readableStreamBYOBReaderCancelCode, cancel, ASCIILiteral(), s_readableStreamBYOBReaderCancelCodeLength) \
-    macro(readableStreamDefaultReaderCancelCode, cancel, ASCIILiteral(), s_readableStreamDefaultReaderCancelCodeLength) \
-    macro(readableByteStreamControllerCloseCode, close, ASCIILiteral(), s_readableByteStreamControllerCloseCodeLength) \
-    macro(readableStreamDefaultControllerCloseCode, close, ASCIILiteral(), s_readableStreamDefaultControllerCloseCodeLength) \
-    macro(writableStreamDefaultWriterCloseCode, close, ASCIILiteral(), s_writableStreamDefaultWriterCloseCodeLength) \
-    macro(readableStreamBYOBReaderClosedCode, closed, "get closed"_s, s_readableStreamBYOBReaderClosedCodeLength) \
-    macro(readableStreamDefaultReaderClosedCode, closed, "get closed"_s, s_readableStreamDefaultReaderClosedCodeLength) \
-    macro(writableStreamDefaultWriterClosedCode, closed, "get closed"_s, s_writableStreamDefaultWriterClosedCodeLength) \
-    macro(readableStreamConsumeReadableStreamCode, consumeReadableStream, ASCIILiteral(), s_readableStreamConsumeReadableStreamCodeLength) \
-    macro(readableStreamCreateEmptyReadableStreamCode, createEmptyReadableStream, ASCIILiteral(), s_readableStreamCreateEmptyReadableStreamCodeLength) \
-    macro(streamInternalsCreateFIFOCode, createFIFO, ASCIILiteral(), s_streamInternalsCreateFIFOCodeLength) \
-    macro(streamInternalsCreateFulfilledPromiseCode, createFulfilledPromise, ASCIILiteral(), s_streamInternalsCreateFulfilledPromiseCodeLength) \
-    macro(writableStreamInternalsCreateInternalWritableStreamFromUnderlyingSinkCode, createInternalWritableStreamFromUnderlyingSink, ASCIILiteral(), s_writableStreamInternalsCreateInternalWritableStreamFromUnderlyingSinkCodeLength) \
-    macro(readableStreamCreateNativeReadableStreamCode, createNativeReadableStream, ASCIILiteral(), s_readableStreamCreateNativeReadableStreamCodeLength) \
-    macro(readableStreamInternalsCreateReadableStreamControllerCode, createReadableStreamController, ASCIILiteral(), s_readableStreamInternalsCreateReadableStreamControllerCodeLength) \
-    macro(transformStreamInternalsCreateTransformStreamCode, createTransformStream, ASCIILiteral(), s_transformStreamInternalsCreateTransformStreamCodeLength) \
-    macro(writableStreamInternalsCreateWritableStreamCode, createWritableStream, ASCIILiteral(), s_writableStreamInternalsCreateWritableStreamCodeLength) \
-    macro(streamInternalsDequeueValueCode, dequeueValue, ASCIILiteral(), s_streamInternalsDequeueValueCodeLength) \
-    macro(readableByteStreamControllerDesiredSizeCode, desiredSize, "get desiredSize"_s, s_readableByteStreamControllerDesiredSizeCodeLength) \
-    macro(readableStreamDefaultControllerDesiredSizeCode, desiredSize, "get desiredSize"_s, s_readableStreamDefaultControllerDesiredSizeCodeLength) \
-    macro(transformStreamDefaultControllerDesiredSizeCode, desiredSize, "get desiredSize"_s, s_transformStreamDefaultControllerDesiredSizeCodeLength) \
-    macro(writableStreamDefaultWriterDesiredSizeCode, desiredSize, "get desiredSize"_s, s_writableStreamDefaultWriterDesiredSizeCodeLength) \
-    macro(readableByteStreamControllerEnqueueCode, enqueue, ASCIILiteral(), s_readableByteStreamControllerEnqueueCodeLength) \
-    macro(readableStreamDefaultControllerEnqueueCode, enqueue, ASCIILiteral(), s_readableStreamDefaultControllerEnqueueCodeLength) \
-    macro(transformStreamDefaultControllerEnqueueCode, enqueue, ASCIILiteral(), s_transformStreamDefaultControllerEnqueueCodeLength) \
-    macro(streamInternalsEnqueueValueWithSizeCode, enqueueValueWithSize, ASCIILiteral(), s_streamInternalsEnqueueValueWithSizeCodeLength) \
-    macro(readableByteStreamControllerErrorCode, error, ASCIILiteral(), s_readableByteStreamControllerErrorCodeLength) \
-    macro(readableStreamDefaultControllerErrorCode, error, ASCIILiteral(), s_readableStreamDefaultControllerErrorCodeLength) \
-    macro(transformStreamDefaultControllerErrorCode, error, ASCIILiteral(), s_transformStreamDefaultControllerErrorCodeLength) \
-    macro(writableStreamDefaultControllerErrorCode, error, ASCIILiteral(), s_writableStreamDefaultControllerErrorCodeLength) \
-    macro(streamInternalsExtractHighWaterMarkCode, extractHighWaterMark, ASCIILiteral(), s_streamInternalsExtractHighWaterMarkCodeLength) \
-    macro(streamInternalsExtractHighWaterMarkFromQueuingStrategyInitCode, extractHighWaterMarkFromQueuingStrategyInit, ASCIILiteral(), s_streamInternalsExtractHighWaterMarkFromQueuingStrategyInitCodeLength) \
-    macro(streamInternalsExtractSizeAlgorithmCode, extractSizeAlgorithm, ASCIILiteral(), s_streamInternalsExtractSizeAlgorithmCodeLength) \
-    macro(jsBufferConstructorFromCode, from, ASCIILiteral(), s_jsBufferConstructorFromCodeLength) \
-    macro(readableStreamGetReaderCode, getReader, ASCIILiteral(), s_readableStreamGetReaderCodeLength) \
-    macro(readableStreamInternalsHandleDirectStreamErrorCode, handleDirectStreamError, ASCIILiteral(), s_readableStreamInternalsHandleDirectStreamErrorCodeLength) \
-    macro(readableStreamInternalsHandleDirectStreamErrorRejectCode, handleDirectStreamErrorReject, ASCIILiteral(), s_readableStreamInternalsHandleDirectStreamErrorRejectCodeLength) \
-    macro(jsBufferPrototypeHexSliceCode, hexSlice, ASCIILiteral(), s_jsBufferPrototypeHexSliceCodeLength) \
-    macro(jsBufferPrototypeHexWriteCode, hexWrite, ASCIILiteral(), s_jsBufferPrototypeHexWriteCodeLength) \
-    macro(byteLengthQueuingStrategyHighWaterMarkCode, highWaterMark, "get highWaterMark"_s, s_byteLengthQueuingStrategyHighWaterMarkCodeLength) \
-    macro(countQueuingStrategyHighWaterMarkCode, highWaterMark, "get highWaterMark"_s, s_countQueuingStrategyHighWaterMarkCodeLength) \
-    macro(readableStreamInternalsInitializeArrayBufferStreamCode, initializeArrayBufferStream, ASCIILiteral(), s_readableStreamInternalsInitializeArrayBufferStreamCodeLength) \
-    macro(jsBufferPrototypeInitializeBunBufferCode, initializeBunBuffer, ASCIILiteral(), s_jsBufferPrototypeInitializeBunBufferCodeLength) \
-    macro(byteLengthQueuingStrategyInitializeByteLengthQueuingStrategyCode, initializeByteLengthQueuingStrategy, ASCIILiteral(), s_byteLengthQueuingStrategyInitializeByteLengthQueuingStrategyCodeLength) \
-    macro(countQueuingStrategyInitializeCountQueuingStrategyCode, initializeCountQueuingStrategy, ASCIILiteral(), s_countQueuingStrategyInitializeCountQueuingStrategyCodeLength) \
-    macro(readableByteStreamControllerInitializeReadableByteStreamControllerCode, initializeReadableByteStreamController, ASCIILiteral(), s_readableByteStreamControllerInitializeReadableByteStreamControllerCodeLength) \
-    macro(readableStreamInitializeReadableStreamCode, initializeReadableStream, ASCIILiteral(), s_readableStreamInitializeReadableStreamCodeLength) \
-    macro(readableStreamBYOBReaderInitializeReadableStreamBYOBReaderCode, initializeReadableStreamBYOBReader, ASCIILiteral(), s_readableStreamBYOBReaderInitializeReadableStreamBYOBReaderCodeLength) \
-    macro(readableStreamBYOBRequestInitializeReadableStreamBYOBRequestCode, initializeReadableStreamBYOBRequest, ASCIILiteral(), s_readableStreamBYOBRequestInitializeReadableStreamBYOBRequestCodeLength) \
-    macro(readableStreamDefaultControllerInitializeReadableStreamDefaultControllerCode, initializeReadableStreamDefaultController, ASCIILiteral(), s_readableStreamDefaultControllerInitializeReadableStreamDefaultControllerCodeLength) \
-    macro(readableStreamDefaultReaderInitializeReadableStreamDefaultReaderCode, initializeReadableStreamDefaultReader, ASCIILiteral(), s_readableStreamDefaultReaderInitializeReadableStreamDefaultReaderCodeLength) \
-    macro(transformStreamInitializeTransformStreamCode, initializeTransformStream, ASCIILiteral(), s_transformStreamInitializeTransformStreamCodeLength) \
-    macro(transformStreamInternalsInitializeTransformStreamCode, initializeTransformStream, ASCIILiteral(), s_transformStreamInternalsInitializeTransformStreamCodeLength) \
-    macro(transformStreamDefaultControllerInitializeTransformStreamDefaultControllerCode, initializeTransformStreamDefaultController, ASCIILiteral(), s_transformStreamDefaultControllerInitializeTransformStreamDefaultControllerCodeLength) \
-    macro(writableStreamDefaultControllerInitializeWritableStreamDefaultControllerCode, initializeWritableStreamDefaultController, ASCIILiteral(), s_writableStreamDefaultControllerInitializeWritableStreamDefaultControllerCodeLength) \
-    macro(writableStreamDefaultWriterInitializeWritableStreamDefaultWriterCode, initializeWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamDefaultWriterInitializeWritableStreamDefaultWriterCodeLength) \
-    macro(writableStreamInternalsInitializeWritableStreamSlotsCode, initializeWritableStreamSlots, ASCIILiteral(), s_writableStreamInternalsInitializeWritableStreamSlotsCodeLength) \
-    macro(writableStreamInternalsIsCloseSentinelCode, isCloseSentinel, ASCIILiteral(), s_writableStreamInternalsIsCloseSentinelCodeLength) \
-    macro(readableByteStreamInternalsIsReadableByteStreamControllerCode, isReadableByteStreamController, ASCIILiteral(), s_readableByteStreamInternalsIsReadableByteStreamControllerCodeLength) \
-    macro(readableStreamInternalsIsReadableStreamCode, isReadableStream, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamCodeLength) \
-    macro(readableByteStreamInternalsIsReadableStreamBYOBReaderCode, isReadableStreamBYOBReader, ASCIILiteral(), s_readableByteStreamInternalsIsReadableStreamBYOBReaderCodeLength) \
-    macro(readableByteStreamInternalsIsReadableStreamBYOBRequestCode, isReadableStreamBYOBRequest, ASCIILiteral(), s_readableByteStreamInternalsIsReadableStreamBYOBRequestCodeLength) \
-    macro(readableStreamInternalsIsReadableStreamDefaultControllerCode, isReadableStreamDefaultController, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDefaultControllerCodeLength) \
-    macro(readableStreamInternalsIsReadableStreamDefaultReaderCode, isReadableStreamDefaultReader, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDefaultReaderCodeLength) \
-    macro(readableStreamInternalsIsReadableStreamDisturbedCode, isReadableStreamDisturbed, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDisturbedCodeLength) \
-    macro(readableStreamInternalsIsReadableStreamLockedCode, isReadableStreamLocked, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamLockedCodeLength) \
-    macro(transformStreamInternalsIsTransformStreamCode, isTransformStream, ASCIILiteral(), s_transformStreamInternalsIsTransformStreamCodeLength) \
-    macro(transformStreamInternalsIsTransformStreamDefaultControllerCode, isTransformStreamDefaultController, ASCIILiteral(), s_transformStreamInternalsIsTransformStreamDefaultControllerCodeLength) \
-    macro(writableStreamInternalsIsWritableStreamCode, isWritableStream, ASCIILiteral(), s_writableStreamInternalsIsWritableStreamCodeLength) \
-    macro(writableStreamInternalsIsWritableStreamDefaultWriterCode, isWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamInternalsIsWritableStreamDefaultWriterCodeLength) \
-    macro(writableStreamInternalsIsWritableStreamLockedCode, isWritableStreamLocked, ASCIILiteral(), s_writableStreamInternalsIsWritableStreamLockedCodeLength) \
-    macro(jsBufferPrototypeLatin1SliceCode, latin1Slice, ASCIILiteral(), s_jsBufferPrototypeLatin1SliceCodeLength) \
-    macro(jsBufferPrototypeLatin1WriteCode, latin1Write, ASCIILiteral(), s_jsBufferPrototypeLatin1WriteCodeLength) \
-    macro(readableStreamInternalsLazyLoadStreamCode, lazyLoadStream, ASCIILiteral(), s_readableStreamInternalsLazyLoadStreamCodeLength) \
-    macro(readableStreamLockedCode, locked, "get locked"_s, s_readableStreamLockedCodeLength) \
-    macro(streamInternalsMarkPromiseAsHandledCode, markPromiseAsHandled, ASCIILiteral(), s_streamInternalsMarkPromiseAsHandledCodeLength) \
-    macro(streamInternalsNewQueueCode, newQueue, ASCIILiteral(), s_streamInternalsNewQueueCodeLength) \
-    macro(readableStreamInternalsNoopDoneFunctionCode, noopDoneFunction, ASCIILiteral(), s_readableStreamInternalsNoopDoneFunctionCodeLength) \
-    macro(readableStreamInternalsOnCloseDirectStreamCode, onCloseDirectStream, ASCIILiteral(), s_readableStreamInternalsOnCloseDirectStreamCodeLength) \
-    macro(readableStreamInternalsOnDrainDirectStreamCode, onDrainDirectStream, ASCIILiteral(), s_readableStreamInternalsOnDrainDirectStreamCodeLength) \
-    macro(readableStreamInternalsOnPullDirectStreamCode, onPullDirectStream, ASCIILiteral(), s_readableStreamInternalsOnPullDirectStreamCodeLength) \
-    macro(readableStreamInternalsOnReadableStreamDirectControllerClosedCode, onReadableStreamDirectControllerClosed, ASCIILiteral(), s_readableStreamInternalsOnReadableStreamDirectControllerClosedCodeLength) \
-    macro(streamInternalsPeekQueueValueCode, peekQueueValue, ASCIILiteral(), s_streamInternalsPeekQueueValueCodeLength) \
-    macro(readableStreamPipeThroughCode, pipeThrough, ASCIILiteral(), s_readableStreamPipeThroughCodeLength) \
-    macro(readableStreamPipeToCode, pipeTo, ASCIILiteral(), s_readableStreamPipeToCodeLength) \
-    macro(readableStreamInternalsPipeToClosingMustBePropagatedBackwardCode, pipeToClosingMustBePropagatedBackward, ASCIILiteral(), s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCodeLength) \
-    macro(readableStreamInternalsPipeToClosingMustBePropagatedForwardCode, pipeToClosingMustBePropagatedForward, ASCIILiteral(), s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCodeLength) \
-    macro(readableStreamInternalsPipeToDoReadWriteCode, pipeToDoReadWrite, ASCIILiteral(), s_readableStreamInternalsPipeToDoReadWriteCodeLength) \
-    macro(readableStreamInternalsPipeToErrorsMustBePropagatedBackwardCode, pipeToErrorsMustBePropagatedBackward, ASCIILiteral(), s_readableStreamInternalsPipeToErrorsMustBePropagatedBackwardCodeLength) \
-    macro(readableStreamInternalsPipeToErrorsMustBePropagatedForwardCode, pipeToErrorsMustBePropagatedForward, ASCIILiteral(), s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCodeLength) \
-    macro(readableStreamInternalsPipeToFinalizeCode, pipeToFinalize, ASCIILiteral(), s_readableStreamInternalsPipeToFinalizeCodeLength) \
-    macro(readableStreamInternalsPipeToLoopCode, pipeToLoop, ASCIILiteral(), s_readableStreamInternalsPipeToLoopCodeLength) \
-    macro(readableStreamInternalsPipeToShutdownCode, pipeToShutdown, ASCIILiteral(), s_readableStreamInternalsPipeToShutdownCodeLength) \
-    macro(readableStreamInternalsPipeToShutdownWithActionCode, pipeToShutdownWithAction, ASCIILiteral(), s_readableStreamInternalsPipeToShutdownWithActionCodeLength) \
-    macro(readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCode, privateInitializeReadableByteStreamController, ASCIILiteral(), s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCodeLength) \
-    macro(readableByteStreamInternalsPrivateInitializeReadableStreamBYOBRequestCode, privateInitializeReadableStreamBYOBRequest, ASCIILiteral(), s_readableByteStreamInternalsPrivateInitializeReadableStreamBYOBRequestCodeLength) \
-    macro(readableStreamInternalsPrivateInitializeReadableStreamDefaultControllerCode, privateInitializeReadableStreamDefaultController, ASCIILiteral(), s_readableStreamInternalsPrivateInitializeReadableStreamDefaultControllerCodeLength) \
-    macro(streamInternalsPromiseInvokeOrFallbackOrNoopCode, promiseInvokeOrFallbackOrNoop, ASCIILiteral(), s_streamInternalsPromiseInvokeOrFallbackOrNoopCodeLength) \
-    macro(streamInternalsPromiseInvokeOrNoopCode, promiseInvokeOrNoop, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopCodeLength) \
-    macro(streamInternalsPromiseInvokeOrNoopMethodCode, promiseInvokeOrNoopMethod, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopMethodCodeLength) \
-    macro(streamInternalsPromiseInvokeOrNoopMethodNoCatchCode, promiseInvokeOrNoopMethodNoCatch, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopMethodNoCatchCodeLength) \
-    macro(streamInternalsPromiseInvokeOrNoopNoCatchCode, promiseInvokeOrNoopNoCatch, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopNoCatchCodeLength) \
-    macro(readableStreamBYOBReaderReadCode, read, ASCIILiteral(), s_readableStreamBYOBReaderReadCodeLength) \
-    macro(readableStreamDefaultReaderReadCode, read, ASCIILiteral(), s_readableStreamDefaultReaderReadCodeLength) \
-    macro(jsBufferPrototypeReadBigInt64BECode, readBigInt64BE, ASCIILiteral(), s_jsBufferPrototypeReadBigInt64BECodeLength) \
-    macro(jsBufferPrototypeReadBigInt64LECode, readBigInt64LE, ASCIILiteral(), s_jsBufferPrototypeReadBigInt64LECodeLength) \
-    macro(jsBufferPrototypeReadBigUInt64BECode, readBigUInt64BE, ASCIILiteral(), s_jsBufferPrototypeReadBigUInt64BECodeLength) \
-    macro(jsBufferPrototypeReadBigUInt64LECode, readBigUInt64LE, ASCIILiteral(), s_jsBufferPrototypeReadBigUInt64LECodeLength) \
-    macro(jsBufferPrototypeReadDoubleBECode, readDoubleBE, ASCIILiteral(), s_jsBufferPrototypeReadDoubleBECodeLength) \
-    macro(jsBufferPrototypeReadDoubleLECode, readDoubleLE, ASCIILiteral(), s_jsBufferPrototypeReadDoubleLECodeLength) \
-    macro(jsBufferPrototypeReadFloatBECode, readFloatBE, ASCIILiteral(), s_jsBufferPrototypeReadFloatBECodeLength) \
-    macro(jsBufferPrototypeReadFloatLECode, readFloatLE, ASCIILiteral(), s_jsBufferPrototypeReadFloatLECodeLength) \
-    macro(jsBufferPrototypeReadInt16BECode, readInt16BE, ASCIILiteral(), s_jsBufferPrototypeReadInt16BECodeLength) \
-    macro(jsBufferPrototypeReadInt16LECode, readInt16LE, ASCIILiteral(), s_jsBufferPrototypeReadInt16LECodeLength) \
-    macro(jsBufferPrototypeReadInt32BECode, readInt32BE, ASCIILiteral(), s_jsBufferPrototypeReadInt32BECodeLength) \
-    macro(jsBufferPrototypeReadInt32LECode, readInt32LE, ASCIILiteral(), s_jsBufferPrototypeReadInt32LECodeLength) \
-    macro(jsBufferPrototypeReadInt8Code, readInt8, ASCIILiteral(), s_jsBufferPrototypeReadInt8CodeLength) \
-    macro(readableStreamDefaultReaderReadManyCode, readMany, ASCIILiteral(), s_readableStreamDefaultReaderReadManyCodeLength) \
-    macro(jsBufferPrototypeReadUInt16BECode, readUInt16BE, ASCIILiteral(), s_jsBufferPrototypeReadUInt16BECodeLength) \
-    macro(jsBufferPrototypeReadUInt16LECode, readUInt16LE, ASCIILiteral(), s_jsBufferPrototypeReadUInt16LECodeLength) \
-    macro(jsBufferPrototypeReadUInt32BECode, readUInt32BE, ASCIILiteral(), s_jsBufferPrototypeReadUInt32BECodeLength) \
-    macro(jsBufferPrototypeReadUInt32LECode, readUInt32LE, ASCIILiteral(), s_jsBufferPrototypeReadUInt32LECodeLength) \
-    macro(jsBufferPrototypeReadUInt8Code, readUInt8, ASCIILiteral(), s_jsBufferPrototypeReadUInt8CodeLength) \
-    macro(transformStreamReadableCode, readable, "get readable"_s, s_transformStreamReadableCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerCallPullIfNeededCode, readableByteStreamControllerCallPullIfNeeded, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCallPullIfNeededCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerCancelCode, readableByteStreamControllerCancel, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCancelCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerClearPendingPullIntosCode, readableByteStreamControllerClearPendingPullIntos, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerClearPendingPullIntosCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerCloseCode, readableByteStreamControllerClose, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCloseCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerCommitDescriptorCode, readableByteStreamControllerCommitDescriptor, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCommitDescriptorCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerConvertDescriptorCode, readableByteStreamControllerConvertDescriptor, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerConvertDescriptorCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerEnqueueCode, readableByteStreamControllerEnqueue, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerEnqueueCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerEnqueueChunkCode, readableByteStreamControllerEnqueueChunk, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerEnqueueChunkCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerErrorCode, readableByteStreamControllerError, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerErrorCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerFillDescriptorFromQueueCode, readableByteStreamControllerFillDescriptorFromQueue, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerFillDescriptorFromQueueCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerGetDesiredSizeCode, readableByteStreamControllerGetDesiredSize, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerGetDesiredSizeCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerHandleQueueDrainCode, readableByteStreamControllerHandleQueueDrain, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerHandleQueueDrainCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerInvalidateBYOBRequestCode, readableByteStreamControllerInvalidateBYOBRequest, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerInvalidateBYOBRequestCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerProcessPullDescriptorsCode, readableByteStreamControllerProcessPullDescriptors, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerProcessPullDescriptorsCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerPullCode, readableByteStreamControllerPull, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerPullCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerPullIntoCode, readableByteStreamControllerPullInto, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerPullIntoCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerRespondCode, readableByteStreamControllerRespond, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerRespondInClosedStateCode, readableByteStreamControllerRespondInClosedState, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondInClosedStateCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerRespondInReadableStateCode, readableByteStreamControllerRespondInReadableState, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondInReadableStateCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerRespondInternalCode, readableByteStreamControllerRespondInternal, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondInternalCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerRespondWithNewViewCode, readableByteStreamControllerRespondWithNewView, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondWithNewViewCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerShiftPendingDescriptorCode, readableByteStreamControllerShiftPendingDescriptor, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerShiftPendingDescriptorCodeLength) \
-    macro(readableByteStreamInternalsReadableByteStreamControllerShouldCallPullCode, readableByteStreamControllerShouldCallPull, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerShouldCallPullCodeLength) \
-    macro(readableByteStreamInternalsReadableStreamAddReadIntoRequestCode, readableStreamAddReadIntoRequest, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamAddReadIntoRequestCodeLength) \
-    macro(readableStreamInternalsReadableStreamAddReadRequestCode, readableStreamAddReadRequest, ASCIILiteral(), s_readableStreamInternalsReadableStreamAddReadRequestCodeLength) \
-    macro(readableByteStreamInternalsReadableStreamBYOBReaderReadCode, readableStreamBYOBReaderRead, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamBYOBReaderReadCodeLength) \
-    macro(readableByteStreamInternalsReadableStreamByteStreamControllerStartCode, readableStreamByteStreamControllerStart, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCodeLength) \
-    macro(readableStreamInternalsReadableStreamCancelCode, readableStreamCancel, ASCIILiteral(), s_readableStreamInternalsReadableStreamCancelCodeLength) \
-    macro(readableStreamInternalsReadableStreamCloseCode, readableStreamClose, ASCIILiteral(), s_readableStreamInternalsReadableStreamCloseCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerCallPullIfNeededCode, readableStreamDefaultControllerCallPullIfNeeded, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCallPullIfNeededCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerCanCloseOrEnqueueCode, readableStreamDefaultControllerCanCloseOrEnqueue, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCanCloseOrEnqueueCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerCancelCode, readableStreamDefaultControllerCancel, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCancelCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerCloseCode, readableStreamDefaultControllerClose, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCloseCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerEnqueueCode, readableStreamDefaultControllerEnqueue, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerEnqueueCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerErrorCode, readableStreamDefaultControllerError, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerErrorCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerGetDesiredSizeCode, readableStreamDefaultControllerGetDesiredSize, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerGetDesiredSizeCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerPullCode, readableStreamDefaultControllerPull, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerPullCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerShouldCallPullCode, readableStreamDefaultControllerShouldCallPull, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerShouldCallPullCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultControllerStartCode, readableStreamDefaultControllerStart, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerStartCodeLength) \
-    macro(readableStreamInternalsReadableStreamDefaultReaderReadCode, readableStreamDefaultReaderRead, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultReaderReadCodeLength) \
-    macro(readableStreamInternalsReadableStreamErrorCode, readableStreamError, ASCIILiteral(), s_readableStreamInternalsReadableStreamErrorCodeLength) \
-    macro(readableByteStreamInternalsReadableStreamFulfillReadIntoRequestCode, readableStreamFulfillReadIntoRequest, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamFulfillReadIntoRequestCodeLength) \
-    macro(readableStreamInternalsReadableStreamFulfillReadRequestCode, readableStreamFulfillReadRequest, ASCIILiteral(), s_readableStreamInternalsReadableStreamFulfillReadRequestCodeLength) \
-    macro(readableByteStreamInternalsReadableStreamHasBYOBReaderCode, readableStreamHasBYOBReader, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamHasBYOBReaderCodeLength) \
-    macro(readableByteStreamInternalsReadableStreamHasDefaultReaderCode, readableStreamHasDefaultReader, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamHasDefaultReaderCodeLength) \
-    macro(readableStreamInternalsReadableStreamPipeToCode, readableStreamPipeTo, ASCIILiteral(), s_readableStreamInternalsReadableStreamPipeToCodeLength) \
-    macro(readableStreamInternalsReadableStreamPipeToWritableStreamCode, readableStreamPipeToWritableStream, ASCIILiteral(), s_readableStreamInternalsReadableStreamPipeToWritableStreamCodeLength) \
-    macro(readableStreamInternalsReadableStreamReaderGenericCancelCode, readableStreamReaderGenericCancel, ASCIILiteral(), s_readableStreamInternalsReadableStreamReaderGenericCancelCodeLength) \
-    macro(readableStreamInternalsReadableStreamReaderGenericInitializeCode, readableStreamReaderGenericInitialize, ASCIILiteral(), s_readableStreamInternalsReadableStreamReaderGenericInitializeCodeLength) \
-    macro(readableStreamInternalsReadableStreamReaderGenericReleaseCode, readableStreamReaderGenericRelease, ASCIILiteral(), s_readableStreamInternalsReadableStreamReaderGenericReleaseCodeLength) \
-    macro(readableByteStreamInternalsReadableStreamReaderKindCode, readableStreamReaderKind, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamReaderKindCodeLength) \
-    macro(readableStreamInternalsReadableStreamTeeCode, readableStreamTee, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeeCodeLength) \
-    macro(readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCode, readableStreamTeeBranch1CancelFunction, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeLength) \
-    macro(readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCode, readableStreamTeeBranch2CancelFunction, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeLength) \
-    macro(readableStreamInternalsReadableStreamTeePullFunctionCode, readableStreamTeePullFunction, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeePullFunctionCodeLength) \
-    macro(readableStreamReadableStreamToArrayCode, readableStreamToArray, ASCIILiteral(), s_readableStreamReadableStreamToArrayCodeLength) \
-    macro(readableStreamReadableStreamToArrayPublicCode, readableStreamToArrayPublic, ASCIILiteral(), s_readableStreamReadableStreamToArrayPublicCodeLength) \
-    macro(readableStreamReadableStreamToBlobCode, readableStreamToBlob, ASCIILiteral(), s_readableStreamReadableStreamToBlobCodeLength) \
-    macro(readableStreamReadableStreamToJSONCode, readableStreamToJSON, ASCIILiteral(), s_readableStreamReadableStreamToJSONCodeLength) \
-    macro(readableStreamReadableStreamToTextCode, readableStreamToText, ASCIILiteral(), s_readableStreamReadableStreamToTextCodeLength) \
-    macro(writableStreamDefaultWriterReadyCode, ready, "get ready"_s, s_writableStreamDefaultWriterReadyCodeLength) \
-    macro(readableStreamBYOBReaderReleaseLockCode, releaseLock, ASCIILiteral(), s_readableStreamBYOBReaderReleaseLockCodeLength) \
-    macro(readableStreamDefaultReaderReleaseLockCode, releaseLock, ASCIILiteral(), s_readableStreamDefaultReaderReleaseLockCodeLength) \
-    macro(writableStreamDefaultWriterReleaseLockCode, releaseLock, ASCIILiteral(), s_writableStreamDefaultWriterReleaseLockCodeLength) \
-    macro(jsZigGlobalObjectRequireCode, require, ASCIILiteral(), s_jsZigGlobalObjectRequireCodeLength) \
-    macro(streamInternalsResetQueueCode, resetQueue, ASCIILiteral(), s_streamInternalsResetQueueCodeLength) \
-    macro(readableStreamBYOBRequestRespondCode, respond, ASCIILiteral(), s_readableStreamBYOBRequestRespondCodeLength) \
-    macro(readableStreamBYOBRequestRespondWithNewViewCode, respondWithNewView, ASCIILiteral(), s_readableStreamBYOBRequestRespondWithNewViewCodeLength) \
-    macro(jsBufferPrototypeSetBigUint64Code, setBigUint64, ASCIILiteral(), s_jsBufferPrototypeSetBigUint64CodeLength) \
-    macro(transformStreamInternalsSetUpTransformStreamDefaultControllerCode, setUpTransformStreamDefaultController, ASCIILiteral(), s_transformStreamInternalsSetUpTransformStreamDefaultControllerCodeLength) \
-    macro(transformStreamInternalsSetUpTransformStreamDefaultControllerFromTransformerCode, setUpTransformStreamDefaultControllerFromTransformer, ASCIILiteral(), s_transformStreamInternalsSetUpTransformStreamDefaultControllerFromTransformerCodeLength) \
-    macro(writableStreamInternalsSetUpWritableStreamDefaultControllerCode, setUpWritableStreamDefaultController, ASCIILiteral(), s_writableStreamInternalsSetUpWritableStreamDefaultControllerCodeLength) \
-    macro(writableStreamInternalsSetUpWritableStreamDefaultControllerFromUnderlyingSinkCode, setUpWritableStreamDefaultControllerFromUnderlyingSink, ASCIILiteral(), s_writableStreamInternalsSetUpWritableStreamDefaultControllerFromUnderlyingSinkCodeLength) \
-    macro(writableStreamInternalsSetUpWritableStreamDefaultWriterCode, setUpWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamInternalsSetUpWritableStreamDefaultWriterCodeLength) \
-    macro(readableStreamInternalsSetupReadableStreamDefaultControllerCode, setupReadableStreamDefaultController, ASCIILiteral(), s_readableStreamInternalsSetupReadableStreamDefaultControllerCodeLength) \
-    macro(streamInternalsShieldingPromiseResolveCode, shieldingPromiseResolve, ASCIILiteral(), s_streamInternalsShieldingPromiseResolveCodeLength) \
-    macro(byteLengthQueuingStrategySizeCode, size, ASCIILiteral(), s_byteLengthQueuingStrategySizeCodeLength) \
-    macro(countQueuingStrategySizeCode, size, ASCIILiteral(), s_countQueuingStrategySizeCodeLength) \
-    macro(jsBufferPrototypeSliceCode, slice, ASCIILiteral(), s_jsBufferPrototypeSliceCodeLength) \
-    macro(jsBufferPrototypeSubarrayCode, subarray, ASCIILiteral(), s_jsBufferPrototypeSubarrayCodeLength) \
-    macro(readableStreamTeeCode, tee, ASCIILiteral(), s_readableStreamTeeCodeLength) \
-    macro(transformStreamDefaultControllerTerminateCode, terminate, ASCIILiteral(), s_transformStreamDefaultControllerTerminateCodeLength) \
-    macro(streamInternalsToDictionaryCode, toDictionary, ASCIILiteral(), s_streamInternalsToDictionaryCodeLength) \
-    macro(jsBufferPrototypeToJSONCode, toJSON, ASCIILiteral(), s_jsBufferPrototypeToJSONCodeLength) \
-    macro(readableByteStreamInternalsTransferBufferToCurrentRealmCode, transferBufferToCurrentRealm, ASCIILiteral(), s_readableByteStreamInternalsTransferBufferToCurrentRealmCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultControllerClearAlgorithmsCode, transformStreamDefaultControllerClearAlgorithms, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerClearAlgorithmsCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultControllerEnqueueCode, transformStreamDefaultControllerEnqueue, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerEnqueueCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultControllerErrorCode, transformStreamDefaultControllerError, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerErrorCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultControllerPerformTransformCode, transformStreamDefaultControllerPerformTransform, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultControllerTerminateCode, transformStreamDefaultControllerTerminate, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerTerminateCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultSinkAbortAlgorithmCode, transformStreamDefaultSinkAbortAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSinkAbortAlgorithmCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCode, transformStreamDefaultSinkCloseAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCode, transformStreamDefaultSinkWriteAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeLength) \
-    macro(transformStreamInternalsTransformStreamDefaultSourcePullAlgorithmCode, transformStreamDefaultSourcePullAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSourcePullAlgorithmCodeLength) \
-    macro(transformStreamInternalsTransformStreamErrorCode, transformStreamError, ASCIILiteral(), s_transformStreamInternalsTransformStreamErrorCodeLength) \
-    macro(transformStreamInternalsTransformStreamErrorWritableAndUnblockWriteCode, transformStreamErrorWritableAndUnblockWrite, ASCIILiteral(), s_transformStreamInternalsTransformStreamErrorWritableAndUnblockWriteCodeLength) \
-    macro(transformStreamInternalsTransformStreamSetBackpressureCode, transformStreamSetBackpressure, ASCIILiteral(), s_transformStreamInternalsTransformStreamSetBackpressureCodeLength) \
-    macro(jsBufferPrototypeUcs2SliceCode, ucs2Slice, ASCIILiteral(), s_jsBufferPrototypeUcs2SliceCodeLength) \
-    macro(jsBufferPrototypeUcs2WriteCode, ucs2Write, ASCIILiteral(), s_jsBufferPrototypeUcs2WriteCodeLength) \
-    macro(jsBufferPrototypeUtf16leSliceCode, utf16leSlice, ASCIILiteral(), s_jsBufferPrototypeUtf16leSliceCodeLength) \
-    macro(jsBufferPrototypeUtf16leWriteCode, utf16leWrite, ASCIILiteral(), s_jsBufferPrototypeUtf16leWriteCodeLength) \
-    macro(jsBufferPrototypeUtf8SliceCode, utf8Slice, ASCIILiteral(), s_jsBufferPrototypeUtf8SliceCodeLength) \
-    macro(jsBufferPrototypeUtf8WriteCode, utf8Write, ASCIILiteral(), s_jsBufferPrototypeUtf8WriteCodeLength) \
-    macro(streamInternalsValidateAndNormalizeQueuingStrategyCode, validateAndNormalizeQueuingStrategy, ASCIILiteral(), s_streamInternalsValidateAndNormalizeQueuingStrategyCodeLength) \
-    macro(readableStreamBYOBRequestViewCode, view, "get view"_s, s_readableStreamBYOBRequestViewCodeLength) \
-    macro(transformStreamWritableCode, writable, ASCIILiteral(), s_transformStreamWritableCodeLength) \
-    macro(writableStreamInternalsWritableStreamAbortCode, writableStreamAbort, ASCIILiteral(), s_writableStreamInternalsWritableStreamAbortCodeLength) \
-    macro(writableStreamInternalsWritableStreamAbortForBindingsCode, writableStreamAbortForBindings, ASCIILiteral(), s_writableStreamInternalsWritableStreamAbortForBindingsCodeLength) \
-    macro(writableStreamInternalsWritableStreamAddWriteRequestCode, writableStreamAddWriteRequest, ASCIILiteral(), s_writableStreamInternalsWritableStreamAddWriteRequestCodeLength) \
-    macro(writableStreamInternalsWritableStreamCloseCode, writableStreamClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamCloseCodeLength) \
-    macro(writableStreamInternalsWritableStreamCloseForBindingsCode, writableStreamCloseForBindings, ASCIILiteral(), s_writableStreamInternalsWritableStreamCloseForBindingsCodeLength) \
-    macro(writableStreamInternalsWritableStreamCloseQueuedOrInFlightCode, writableStreamCloseQueuedOrInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamCloseQueuedOrInFlightCodeLength) \
-    macro(writableStreamInternalsWritableStreamDealWithRejectionCode, writableStreamDealWithRejection, ASCIILiteral(), s_writableStreamInternalsWritableStreamDealWithRejectionCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerAdvanceQueueIfNeededCode, writableStreamDefaultControllerAdvanceQueueIfNeeded, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerAdvanceQueueIfNeededCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerClearAlgorithmsCode, writableStreamDefaultControllerClearAlgorithms, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerClearAlgorithmsCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerCloseCode, writableStreamDefaultControllerClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerCloseCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerErrorCode, writableStreamDefaultControllerError, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerErrorCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerErrorIfNeededCode, writableStreamDefaultControllerErrorIfNeeded, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerErrorIfNeededCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerGetBackpressureCode, writableStreamDefaultControllerGetBackpressure, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerGetBackpressureCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerGetChunkSizeCode, writableStreamDefaultControllerGetChunkSize, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerGetChunkSizeCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerGetDesiredSizeCode, writableStreamDefaultControllerGetDesiredSize, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerGetDesiredSizeCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerProcessCloseCode, writableStreamDefaultControllerProcessClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerProcessCloseCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerProcessWriteCode, writableStreamDefaultControllerProcessWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerProcessWriteCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerStartCode, writableStreamDefaultControllerStart, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerStartCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultControllerWriteCode, writableStreamDefaultControllerWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerWriteCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterAbortCode, writableStreamDefaultWriterAbort, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterAbortCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterCloseCode, writableStreamDefaultWriterClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterCloseCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterCloseWithErrorPropagationCode, writableStreamDefaultWriterCloseWithErrorPropagation, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterCloseWithErrorPropagationCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterEnsureClosedPromiseRejectedCode, writableStreamDefaultWriterEnsureClosedPromiseRejected, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterEnsureClosedPromiseRejectedCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterEnsureReadyPromiseRejectedCode, writableStreamDefaultWriterEnsureReadyPromiseRejected, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterEnsureReadyPromiseRejectedCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterGetDesiredSizeCode, writableStreamDefaultWriterGetDesiredSize, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterGetDesiredSizeCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterReleaseCode, writableStreamDefaultWriterRelease, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterReleaseCodeLength) \
-    macro(writableStreamInternalsWritableStreamDefaultWriterWriteCode, writableStreamDefaultWriterWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterWriteCodeLength) \
-    macro(writableStreamInternalsWritableStreamFinishErroringCode, writableStreamFinishErroring, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishErroringCodeLength) \
-    macro(writableStreamInternalsWritableStreamFinishInFlightCloseCode, writableStreamFinishInFlightClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightCloseCodeLength) \
-    macro(writableStreamInternalsWritableStreamFinishInFlightCloseWithErrorCode, writableStreamFinishInFlightCloseWithError, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightCloseWithErrorCodeLength) \
-    macro(writableStreamInternalsWritableStreamFinishInFlightWriteCode, writableStreamFinishInFlightWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightWriteCodeLength) \
-    macro(writableStreamInternalsWritableStreamFinishInFlightWriteWithErrorCode, writableStreamFinishInFlightWriteWithError, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightWriteWithErrorCodeLength) \
-    macro(writableStreamInternalsWritableStreamHasOperationMarkedInFlightCode, writableStreamHasOperationMarkedInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamHasOperationMarkedInFlightCodeLength) \
-    macro(writableStreamInternalsWritableStreamMarkCloseRequestInFlightCode, writableStreamMarkCloseRequestInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamMarkCloseRequestInFlightCodeLength) \
-    macro(writableStreamInternalsWritableStreamMarkFirstWriteRequestInFlightCode, writableStreamMarkFirstWriteRequestInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamMarkFirstWriteRequestInFlightCodeLength) \
-    macro(writableStreamInternalsWritableStreamRejectCloseAndClosedPromiseIfNeededCode, writableStreamRejectCloseAndClosedPromiseIfNeeded, ASCIILiteral(), s_writableStreamInternalsWritableStreamRejectCloseAndClosedPromiseIfNeededCodeLength) \
-    macro(writableStreamInternalsWritableStreamStartErroringCode, writableStreamStartErroring, ASCIILiteral(), s_writableStreamInternalsWritableStreamStartErroringCodeLength) \
-    macro(writableStreamInternalsWritableStreamUpdateBackpressureCode, writableStreamUpdateBackpressure, ASCIILiteral(), s_writableStreamInternalsWritableStreamUpdateBackpressureCodeLength) \
-    macro(writableStreamDefaultWriterWriteCode, write, ASCIILiteral(), s_writableStreamDefaultWriterWriteCodeLength) \
-    macro(jsBufferPrototypeWriteBigInt64BECode, writeBigInt64BE, ASCIILiteral(), s_jsBufferPrototypeWriteBigInt64BECodeLength) \
-    macro(jsBufferPrototypeWriteBigInt64LECode, writeBigInt64LE, ASCIILiteral(), s_jsBufferPrototypeWriteBigInt64LECodeLength) \
-    macro(jsBufferPrototypeWriteBigUInt64BECode, writeBigUInt64BE, ASCIILiteral(), s_jsBufferPrototypeWriteBigUInt64BECodeLength) \
-    macro(jsBufferPrototypeWriteBigUInt64LECode, writeBigUInt64LE, ASCIILiteral(), s_jsBufferPrototypeWriteBigUInt64LECodeLength) \
-    macro(jsBufferPrototypeWriteDoubleBECode, writeDoubleBE, ASCIILiteral(), s_jsBufferPrototypeWriteDoubleBECodeLength) \
-    macro(jsBufferPrototypeWriteDoubleLECode, writeDoubleLE, ASCIILiteral(), s_jsBufferPrototypeWriteDoubleLECodeLength) \
-    macro(jsBufferPrototypeWriteFloatBECode, writeFloatBE, ASCIILiteral(), s_jsBufferPrototypeWriteFloatBECodeLength) \
-    macro(jsBufferPrototypeWriteFloatLECode, writeFloatLE, ASCIILiteral(), s_jsBufferPrototypeWriteFloatLECodeLength) \
-    macro(jsBufferPrototypeWriteInt16BECode, writeInt16BE, ASCIILiteral(), s_jsBufferPrototypeWriteInt16BECodeLength) \
-    macro(jsBufferPrototypeWriteInt16LECode, writeInt16LE, ASCIILiteral(), s_jsBufferPrototypeWriteInt16LECodeLength) \
-    macro(jsBufferPrototypeWriteInt32BECode, writeInt32BE, ASCIILiteral(), s_jsBufferPrototypeWriteInt32BECodeLength) \
-    macro(jsBufferPrototypeWriteInt32LECode, writeInt32LE, ASCIILiteral(), s_jsBufferPrototypeWriteInt32LECodeLength) \
-    macro(jsBufferPrototypeWriteInt8Code, writeInt8, ASCIILiteral(), s_jsBufferPrototypeWriteInt8CodeLength) \
-    macro(jsBufferPrototypeWriteUInt16BECode, writeUInt16BE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt16BECodeLength) \
-    macro(jsBufferPrototypeWriteUInt16LECode, writeUInt16LE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt16LECodeLength) \
-    macro(jsBufferPrototypeWriteUInt32BECode, writeUInt32BE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt32BECodeLength) \
-    macro(jsBufferPrototypeWriteUInt32LECode, writeUInt32LE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt32LECodeLength) \
-    macro(jsBufferPrototypeWriteUInt8Code, writeUInt8, ASCIILiteral(), s_jsBufferPrototypeWriteUInt8CodeLength) \
+#define WEBCORE_FOREACH_BUILTIN_CODE(macro)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+    macro(writableStreamDefaultWriterAbortCode, abort, ASCIILiteral(), s_writableStreamDefaultWriterAbortCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+        macro(readableStreamInternalsAcquireReadableStreamDefaultReaderCode, acquireReadableStreamDefaultReader, ASCIILiteral(), s_readableStreamInternalsAcquireReadableStreamDefaultReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+            macro(writableStreamInternalsAcquireWritableStreamDefaultWriterCode, acquireWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamInternalsAcquireWritableStreamDefaultWriterCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                macro(jsBufferPrototypeAsciiSliceCode, asciiSlice, ASCIILiteral(), s_jsBufferPrototypeAsciiSliceCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                    macro(jsBufferPrototypeAsciiWriteCode, asciiWrite, ASCIILiteral(), s_jsBufferPrototypeAsciiWriteCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                        macro(readableStreamInternalsAssignDirectStreamCode, assignToStream, ASCIILiteral(), s_readableStreamInternalsAssignDirectStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                            macro(jsBufferPrototypeBase64SliceCode, base64Slice, ASCIILiteral(), s_jsBufferPrototypeBase64SliceCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                macro(jsBufferPrototypeBase64WriteCode, base64Write, ASCIILiteral(), s_jsBufferPrototypeBase64WriteCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                    macro(jsBufferPrototypeBase64urlSliceCode, base64urlSlice, ASCIILiteral(), s_jsBufferPrototypeBase64urlSliceCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                        macro(jsBufferPrototypeBase64urlWriteCode, base64urlWrite, ASCIILiteral(), s_jsBufferPrototypeBase64urlWriteCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                            macro(readableByteStreamControllerByobRequestCode, byobRequest, "get byobRequest"_s, s_readableByteStreamControllerByobRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                macro(readableStreamCancelCode, cancel, ASCIILiteral(), s_readableStreamCancelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                    macro(readableStreamBYOBReaderCancelCode, cancel, ASCIILiteral(), s_readableStreamBYOBReaderCancelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                        macro(readableStreamDefaultReaderCancelCode, cancel, ASCIILiteral(), s_readableStreamDefaultReaderCancelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                            macro(readableByteStreamControllerCloseCode, close, ASCIILiteral(), s_readableByteStreamControllerCloseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                macro(readableStreamDefaultControllerCloseCode, close, ASCIILiteral(), s_readableStreamDefaultControllerCloseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                    macro(writableStreamDefaultWriterCloseCode, close, ASCIILiteral(), s_writableStreamDefaultWriterCloseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                        macro(readableStreamBYOBReaderClosedCode, closed, "get closed"_s, s_readableStreamBYOBReaderClosedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                            macro(readableStreamDefaultReaderClosedCode, closed, "get closed"_s, s_readableStreamDefaultReaderClosedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                macro(writableStreamDefaultWriterClosedCode, closed, "get closed"_s, s_writableStreamDefaultWriterClosedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                    macro(readableStreamConsumeReadableStreamCode, consumeReadableStream, ASCIILiteral(), s_readableStreamConsumeReadableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                        macro(readableStreamCreateEmptyReadableStreamCode, createEmptyReadableStream, ASCIILiteral(), s_readableStreamCreateEmptyReadableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                            macro(streamInternalsCreateFIFOCode, createFIFO, ASCIILiteral(), s_streamInternalsCreateFIFOCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                macro(streamInternalsCreateFulfilledPromiseCode, createFulfilledPromise, ASCIILiteral(), s_streamInternalsCreateFulfilledPromiseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                    macro(writableStreamInternalsCreateInternalWritableStreamFromUnderlyingSinkCode, createInternalWritableStreamFromUnderlyingSink, ASCIILiteral(), s_writableStreamInternalsCreateInternalWritableStreamFromUnderlyingSinkCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                        macro(readableStreamCreateNativeReadableStreamCode, createNativeReadableStream, ASCIILiteral(), s_readableStreamCreateNativeReadableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                            macro(readableStreamInternalsCreateReadableStreamControllerCode, createReadableStreamController, ASCIILiteral(), s_readableStreamInternalsCreateReadableStreamControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                macro(transformStreamInternalsCreateTransformStreamCode, createTransformStream, ASCIILiteral(), s_transformStreamInternalsCreateTransformStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                    macro(writableStreamInternalsCreateWritableStreamCode, createWritableStream, ASCIILiteral(), s_writableStreamInternalsCreateWritableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                        macro(streamInternalsDequeueValueCode, dequeueValue, ASCIILiteral(), s_streamInternalsDequeueValueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                            macro(readableByteStreamControllerDesiredSizeCode, desiredSize, "get desiredSize"_s, s_readableByteStreamControllerDesiredSizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                macro(readableStreamDefaultControllerDesiredSizeCode, desiredSize, "get desiredSize"_s, s_readableStreamDefaultControllerDesiredSizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                    macro(transformStreamDefaultControllerDesiredSizeCode, desiredSize, "get desiredSize"_s, s_transformStreamDefaultControllerDesiredSizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                        macro(writableStreamDefaultWriterDesiredSizeCode, desiredSize, "get desiredSize"_s, s_writableStreamDefaultWriterDesiredSizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                            macro(readableByteStreamControllerEnqueueCode, enqueue, ASCIILiteral(), s_readableByteStreamControllerEnqueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                macro(readableStreamDefaultControllerEnqueueCode, enqueue, ASCIILiteral(), s_readableStreamDefaultControllerEnqueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                    macro(transformStreamDefaultControllerEnqueueCode, enqueue, ASCIILiteral(), s_transformStreamDefaultControllerEnqueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                        macro(streamInternalsEnqueueValueWithSizeCode, enqueueValueWithSize, ASCIILiteral(), s_streamInternalsEnqueueValueWithSizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                            macro(readableByteStreamControllerErrorCode, error, ASCIILiteral(), s_readableByteStreamControllerErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                macro(readableStreamDefaultControllerErrorCode, error, ASCIILiteral(), s_readableStreamDefaultControllerErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                    macro(transformStreamDefaultControllerErrorCode, error, ASCIILiteral(), s_transformStreamDefaultControllerErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                        macro(writableStreamDefaultControllerErrorCode, error, ASCIILiteral(), s_writableStreamDefaultControllerErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                            macro(streamInternalsExtractHighWaterMarkCode, extractHighWaterMark, ASCIILiteral(), s_streamInternalsExtractHighWaterMarkCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                macro(streamInternalsExtractHighWaterMarkFromQueuingStrategyInitCode, extractHighWaterMarkFromQueuingStrategyInit, ASCIILiteral(), s_streamInternalsExtractHighWaterMarkFromQueuingStrategyInitCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                    macro(streamInternalsExtractSizeAlgorithmCode, extractSizeAlgorithm, ASCIILiteral(), s_streamInternalsExtractSizeAlgorithmCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                        macro(jsBufferConstructorFromCode, from, ASCIILiteral(), s_jsBufferConstructorFromCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                            macro(readableStreamGetReaderCode, getReader, ASCIILiteral(), s_readableStreamGetReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                macro(readableStreamInternalsHandleDirectStreamErrorCode, handleDirectStreamError, ASCIILiteral(), s_readableStreamInternalsHandleDirectStreamErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                    macro(readableStreamInternalsHandleDirectStreamErrorRejectCode, handleDirectStreamErrorReject, ASCIILiteral(), s_readableStreamInternalsHandleDirectStreamErrorRejectCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                        macro(jsBufferPrototypeHexSliceCode, hexSlice, ASCIILiteral(), s_jsBufferPrototypeHexSliceCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                            macro(jsBufferPrototypeHexWriteCode, hexWrite, ASCIILiteral(), s_jsBufferPrototypeHexWriteCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                macro(byteLengthQueuingStrategyHighWaterMarkCode, highWaterMark, "get highWaterMark"_s, s_byteLengthQueuingStrategyHighWaterMarkCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                    macro(countQueuingStrategyHighWaterMarkCode, highWaterMark, "get highWaterMark"_s, s_countQueuingStrategyHighWaterMarkCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                        macro(readableStreamInternalsInitializeArrayBufferStreamCode, initializeArrayBufferStream, ASCIILiteral(), s_readableStreamInternalsInitializeArrayBufferStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                            macro(jsBufferPrototypeInitializeBunBufferCode, initializeBunBuffer, ASCIILiteral(), s_jsBufferPrototypeInitializeBunBufferCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                macro(byteLengthQueuingStrategyInitializeByteLengthQueuingStrategyCode, initializeByteLengthQueuingStrategy, ASCIILiteral(), s_byteLengthQueuingStrategyInitializeByteLengthQueuingStrategyCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                    macro(countQueuingStrategyInitializeCountQueuingStrategyCode, initializeCountQueuingStrategy, ASCIILiteral(), s_countQueuingStrategyInitializeCountQueuingStrategyCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                        macro(readableByteStreamControllerInitializeReadableByteStreamControllerCode, initializeReadableByteStreamController, ASCIILiteral(), s_readableByteStreamControllerInitializeReadableByteStreamControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                            macro(readableStreamInitializeReadableStreamCode, initializeReadableStream, ASCIILiteral(), s_readableStreamInitializeReadableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                macro(readableStreamBYOBReaderInitializeReadableStreamBYOBReaderCode, initializeReadableStreamBYOBReader, ASCIILiteral(), s_readableStreamBYOBReaderInitializeReadableStreamBYOBReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                    macro(readableStreamBYOBRequestInitializeReadableStreamBYOBRequestCode, initializeReadableStreamBYOBRequest, ASCIILiteral(), s_readableStreamBYOBRequestInitializeReadableStreamBYOBRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                        macro(readableStreamDefaultControllerInitializeReadableStreamDefaultControllerCode, initializeReadableStreamDefaultController, ASCIILiteral(), s_readableStreamDefaultControllerInitializeReadableStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                            macro(readableStreamDefaultReaderInitializeReadableStreamDefaultReaderCode, initializeReadableStreamDefaultReader, ASCIILiteral(), s_readableStreamDefaultReaderInitializeReadableStreamDefaultReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                macro(transformStreamInitializeTransformStreamCode, initializeTransformStream, ASCIILiteral(), s_transformStreamInitializeTransformStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                    macro(transformStreamInternalsInitializeTransformStreamCode, initializeTransformStream, ASCIILiteral(), s_transformStreamInternalsInitializeTransformStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                        macro(transformStreamDefaultControllerInitializeTransformStreamDefaultControllerCode, initializeTransformStreamDefaultController, ASCIILiteral(), s_transformStreamDefaultControllerInitializeTransformStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                            macro(writableStreamDefaultControllerInitializeWritableStreamDefaultControllerCode, initializeWritableStreamDefaultController, ASCIILiteral(), s_writableStreamDefaultControllerInitializeWritableStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                macro(writableStreamDefaultWriterInitializeWritableStreamDefaultWriterCode, initializeWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamDefaultWriterInitializeWritableStreamDefaultWriterCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsInitializeWritableStreamSlotsCode, initializeWritableStreamSlots, ASCIILiteral(), s_writableStreamInternalsInitializeWritableStreamSlotsCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsIsCloseSentinelCode, isCloseSentinel, ASCIILiteral(), s_writableStreamInternalsIsCloseSentinelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsIsReadableByteStreamControllerCode, isReadableByteStreamController, ASCIILiteral(), s_readableByteStreamInternalsIsReadableByteStreamControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsIsReadableStreamCode, isReadableStream, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsIsReadableStreamBYOBReaderCode, isReadableStreamBYOBReader, ASCIILiteral(), s_readableByteStreamInternalsIsReadableStreamBYOBReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsIsReadableStreamBYOBRequestCode, isReadableStreamBYOBRequest, ASCIILiteral(), s_readableByteStreamInternalsIsReadableStreamBYOBRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsIsReadableStreamDefaultControllerCode, isReadableStreamDefaultController, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsIsReadableStreamDefaultReaderCode, isReadableStreamDefaultReader, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDefaultReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsIsReadableStreamDisturbedCode, isReadableStreamDisturbed, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDisturbedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsIsReadableStreamLockedCode, isReadableStreamLocked, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamLockedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                            macro(transformStreamInternalsIsTransformStreamCode, isTransformStream, ASCIILiteral(), s_transformStreamInternalsIsTransformStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                macro(transformStreamInternalsIsTransformStreamDefaultControllerCode, isTransformStreamDefaultController, ASCIILiteral(), s_transformStreamInternalsIsTransformStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsIsWritableStreamCode, isWritableStream, ASCIILiteral(), s_writableStreamInternalsIsWritableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsIsWritableStreamDefaultWriterCode, isWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamInternalsIsWritableStreamDefaultWriterCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsIsWritableStreamLockedCode, isWritableStreamLocked, ASCIILiteral(), s_writableStreamInternalsIsWritableStreamLockedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeLatin1SliceCode, latin1Slice, ASCIILiteral(), s_jsBufferPrototypeLatin1SliceCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeLatin1WriteCode, latin1Write, ASCIILiteral(), s_jsBufferPrototypeLatin1WriteCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsLazyLoadStreamCode, lazyLoadStream, ASCIILiteral(), s_readableStreamInternalsLazyLoadStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamLockedCode, locked, "get locked"_s, s_readableStreamLockedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                macro(streamInternalsMarkPromiseAsHandledCode, markPromiseAsHandled, ASCIILiteral(), s_streamInternalsMarkPromiseAsHandledCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                    macro(streamInternalsNewQueueCode, newQueue, ASCIILiteral(), s_streamInternalsNewQueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsNoopDoneFunctionCode, noopDoneFunction, ASCIILiteral(), s_readableStreamInternalsNoopDoneFunctionCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsOnCloseDirectStreamCode, onCloseDirectStream, ASCIILiteral(), s_readableStreamInternalsOnCloseDirectStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsOnDrainDirectStreamCode, onDrainDirectStream, ASCIILiteral(), s_readableStreamInternalsOnDrainDirectStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsOnPullDirectStreamCode, onPullDirectStream, ASCIILiteral(), s_readableStreamInternalsOnPullDirectStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsOnReadableStreamDirectControllerClosedCode, onReadableStreamDirectControllerClosed, ASCIILiteral(), s_readableStreamInternalsOnReadableStreamDirectControllerClosedCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                            macro(streamInternalsPeekQueueValueCode, peekQueueValue, ASCIILiteral(), s_streamInternalsPeekQueueValueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamPipeThroughCode, pipeThrough, ASCIILiteral(), s_readableStreamPipeThroughCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamPipeToCode, pipeTo, ASCIILiteral(), s_readableStreamPipeToCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsPipeToClosingMustBePropagatedBackwardCode, pipeToClosingMustBePropagatedBackward, ASCIILiteral(), s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsPipeToClosingMustBePropagatedForwardCode, pipeToClosingMustBePropagatedForward, ASCIILiteral(), s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsPipeToDoReadWriteCode, pipeToDoReadWrite, ASCIILiteral(), s_readableStreamInternalsPipeToDoReadWriteCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsPipeToErrorsMustBePropagatedBackwardCode, pipeToErrorsMustBePropagatedBackward, ASCIILiteral(), s_readableStreamInternalsPipeToErrorsMustBePropagatedBackwardCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsPipeToErrorsMustBePropagatedForwardCode, pipeToErrorsMustBePropagatedForward, ASCIILiteral(), s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsPipeToFinalizeCode, pipeToFinalize, ASCIILiteral(), s_readableStreamInternalsPipeToFinalizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsPipeToLoopCode, pipeToLoop, ASCIILiteral(), s_readableStreamInternalsPipeToLoopCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsPipeToShutdownCode, pipeToShutdown, ASCIILiteral(), s_readableStreamInternalsPipeToShutdownCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsPipeToShutdownWithActionCode, pipeToShutdownWithAction, ASCIILiteral(), s_readableStreamInternalsPipeToShutdownWithActionCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCode, privateInitializeReadableByteStreamController, ASCIILiteral(), s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsPrivateInitializeReadableStreamBYOBRequestCode, privateInitializeReadableStreamBYOBRequest, ASCIILiteral(), s_readableByteStreamInternalsPrivateInitializeReadableStreamBYOBRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsPrivateInitializeReadableStreamDefaultControllerCode, privateInitializeReadableStreamDefaultController, ASCIILiteral(), s_readableStreamInternalsPrivateInitializeReadableStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(streamInternalsPromiseInvokeOrFallbackOrNoopCode, promiseInvokeOrFallbackOrNoop, ASCIILiteral(), s_streamInternalsPromiseInvokeOrFallbackOrNoopCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(streamInternalsPromiseInvokeOrNoopCode, promiseInvokeOrNoop, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(streamInternalsPromiseInvokeOrNoopMethodCode, promiseInvokeOrNoopMethod, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopMethodCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(streamInternalsPromiseInvokeOrNoopMethodNoCatchCode, promiseInvokeOrNoopMethodNoCatch, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopMethodNoCatchCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(streamInternalsPromiseInvokeOrNoopNoCatchCode, promiseInvokeOrNoopNoCatch, ASCIILiteral(), s_streamInternalsPromiseInvokeOrNoopNoCatchCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamBYOBReaderReadCode, read, ASCIILiteral(), s_readableStreamBYOBReaderReadCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamDefaultReaderReadCode, read, ASCIILiteral(), s_readableStreamDefaultReaderReadCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeReadBigInt64BECode, readBigInt64BE, ASCIILiteral(), s_jsBufferPrototypeReadBigInt64BECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeReadBigInt64LECode, readBigInt64LE, ASCIILiteral(), s_jsBufferPrototypeReadBigInt64LECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeReadBigUInt64BECode, readBigUInt64BE, ASCIILiteral(), s_jsBufferPrototypeReadBigUInt64BECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeReadBigUInt64LECode, readBigUInt64LE, ASCIILiteral(), s_jsBufferPrototypeReadBigUInt64LECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeReadDoubleBECode, readDoubleBE, ASCIILiteral(), s_jsBufferPrototypeReadDoubleBECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeReadDoubleLECode, readDoubleLE, ASCIILiteral(), s_jsBufferPrototypeReadDoubleLECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeReadFloatBECode, readFloatBE, ASCIILiteral(), s_jsBufferPrototypeReadFloatBECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeReadFloatLECode, readFloatLE, ASCIILiteral(), s_jsBufferPrototypeReadFloatLECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeReadInt16BECode, readInt16BE, ASCIILiteral(), s_jsBufferPrototypeReadInt16BECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeReadInt16LECode, readInt16LE, ASCIILiteral(), s_jsBufferPrototypeReadInt16LECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeReadInt32BECode, readInt32BE, ASCIILiteral(), s_jsBufferPrototypeReadInt32BECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeReadInt32LECode, readInt32LE, ASCIILiteral(), s_jsBufferPrototypeReadInt32LECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeReadInt8Code, readInt8, ASCIILiteral(), s_jsBufferPrototypeReadInt8CodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamDefaultReaderReadManyCode, readMany, ASCIILiteral(), s_readableStreamDefaultReaderReadManyCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeReadUInt16BECode, readUInt16BE, ASCIILiteral(), s_jsBufferPrototypeReadUInt16BECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeReadUInt16LECode, readUInt16LE, ASCIILiteral(), s_jsBufferPrototypeReadUInt16LECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeReadUInt32BECode, readUInt32BE, ASCIILiteral(), s_jsBufferPrototypeReadUInt32BECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeReadUInt32LECode, readUInt32LE, ASCIILiteral(), s_jsBufferPrototypeReadUInt32LECodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeReadUInt8Code, readUInt8, ASCIILiteral(), s_jsBufferPrototypeReadUInt8CodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(transformStreamReadableCode, readable, "get readable"_s, s_transformStreamReadableCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsReadableByteStreamControllerCallPullIfNeededCode, readableByteStreamControllerCallPullIfNeeded, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCallPullIfNeededCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableByteStreamControllerCancelCode, readableByteStreamControllerCancel, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCancelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableByteStreamControllerClearPendingPullIntosCode, readableByteStreamControllerClearPendingPullIntos, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerClearPendingPullIntosCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsReadableByteStreamControllerCloseCode, readableByteStreamControllerClose, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCloseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsReadableByteStreamControllerCommitDescriptorCode, readableByteStreamControllerCommitDescriptor, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerCommitDescriptorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableByteStreamControllerConvertDescriptorCode, readableByteStreamControllerConvertDescriptor, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerConvertDescriptorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableByteStreamControllerEnqueueCode, readableByteStreamControllerEnqueue, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerEnqueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsReadableByteStreamControllerEnqueueChunkCode, readableByteStreamControllerEnqueueChunk, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerEnqueueChunkCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsReadableByteStreamControllerErrorCode, readableByteStreamControllerError, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableByteStreamControllerFillDescriptorFromQueueCode, readableByteStreamControllerFillDescriptorFromQueue, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerFillDescriptorFromQueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableByteStreamControllerGetDesiredSizeCode, readableByteStreamControllerGetDesiredSize, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerGetDesiredSizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsReadableByteStreamControllerHandleQueueDrainCode, readableByteStreamControllerHandleQueueDrain, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerHandleQueueDrainCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsReadableByteStreamControllerInvalidateBYOBRequestCode, readableByteStreamControllerInvalidateBYOBRequest, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerInvalidateBYOBRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableByteStreamControllerProcessPullDescriptorsCode, readableByteStreamControllerProcessPullDescriptors, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerProcessPullDescriptorsCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableByteStreamControllerPullCode, readableByteStreamControllerPull, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerPullCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsReadableByteStreamControllerPullIntoCode, readableByteStreamControllerPullInto, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerPullIntoCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsReadableByteStreamControllerRespondCode, readableByteStreamControllerRespond, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableByteStreamControllerRespondInClosedStateCode, readableByteStreamControllerRespondInClosedState, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondInClosedStateCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableByteStreamControllerRespondInReadableStateCode, readableByteStreamControllerRespondInReadableState, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondInReadableStateCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsReadableByteStreamControllerRespondInternalCode, readableByteStreamControllerRespondInternal, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondInternalCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsReadableByteStreamControllerRespondWithNewViewCode, readableByteStreamControllerRespondWithNewView, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerRespondWithNewViewCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableByteStreamControllerShiftPendingDescriptorCode, readableByteStreamControllerShiftPendingDescriptor, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerShiftPendingDescriptorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableByteStreamControllerShouldCallPullCode, readableByteStreamControllerShouldCallPull, ASCIILiteral(), s_readableByteStreamInternalsReadableByteStreamControllerShouldCallPullCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsReadableStreamAddReadIntoRequestCode, readableStreamAddReadIntoRequest, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamAddReadIntoRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsReadableStreamAddReadRequestCode, readableStreamAddReadRequest, ASCIILiteral(), s_readableStreamInternalsReadableStreamAddReadRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableStreamBYOBReaderReadCode, readableStreamBYOBReaderRead, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamBYOBReaderReadCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableStreamByteStreamControllerStartCode, readableStreamByteStreamControllerStart, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsReadableStreamCancelCode, readableStreamCancel, ASCIILiteral(), s_readableStreamInternalsReadableStreamCancelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsReadableStreamCloseCode, readableStreamClose, ASCIILiteral(), s_readableStreamInternalsReadableStreamCloseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsReadableStreamDefaultControllerCallPullIfNeededCode, readableStreamDefaultControllerCallPullIfNeeded, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCallPullIfNeededCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsReadableStreamDefaultControllerCanCloseOrEnqueueCode, readableStreamDefaultControllerCanCloseOrEnqueue, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCanCloseOrEnqueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsReadableStreamDefaultControllerCancelCode, readableStreamDefaultControllerCancel, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCancelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsReadableStreamDefaultControllerCloseCode, readableStreamDefaultControllerClose, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerCloseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsReadableStreamDefaultControllerEnqueueCode, readableStreamDefaultControllerEnqueue, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerEnqueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsReadableStreamDefaultControllerErrorCode, readableStreamDefaultControllerError, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsReadableStreamDefaultControllerGetDesiredSizeCode, readableStreamDefaultControllerGetDesiredSize, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerGetDesiredSizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsReadableStreamDefaultControllerPullCode, readableStreamDefaultControllerPull, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerPullCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsReadableStreamDefaultControllerShouldCallPullCode, readableStreamDefaultControllerShouldCallPull, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerShouldCallPullCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsReadableStreamDefaultControllerStartCode, readableStreamDefaultControllerStart, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerStartCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsReadableStreamDefaultReaderReadCode, readableStreamDefaultReaderRead, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultReaderReadCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsReadableStreamErrorCode, readableStreamError, ASCIILiteral(), s_readableStreamInternalsReadableStreamErrorCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamInternalsReadableStreamFulfillReadIntoRequestCode, readableStreamFulfillReadIntoRequest, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamFulfillReadIntoRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsReadableStreamFulfillReadRequestCode, readableStreamFulfillReadRequest, ASCIILiteral(), s_readableStreamInternalsReadableStreamFulfillReadRequestCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamInternalsReadableStreamHasBYOBReaderCode, readableStreamHasBYOBReader, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamHasBYOBReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsReadableStreamHasDefaultReaderCode, readableStreamHasDefaultReader, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamHasDefaultReaderCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsReadableStreamPipeToCode, readableStreamPipeTo, ASCIILiteral(), s_readableStreamInternalsReadableStreamPipeToCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsReadableStreamPipeToWritableStreamCode, readableStreamPipeToWritableStream, ASCIILiteral(), s_readableStreamInternalsReadableStreamPipeToWritableStreamCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsReadableStreamReaderGenericCancelCode, readableStreamReaderGenericCancel, ASCIILiteral(), s_readableStreamInternalsReadableStreamReaderGenericCancelCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsReadableStreamReaderGenericInitializeCode, readableStreamReaderGenericInitialize, ASCIILiteral(), s_readableStreamInternalsReadableStreamReaderGenericInitializeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsReadableStreamReaderGenericReleaseCode, readableStreamReaderGenericRelease, ASCIILiteral(), s_readableStreamInternalsReadableStreamReaderGenericReleaseCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamInternalsReadableStreamReaderKindCode, readableStreamReaderKind, ASCIILiteral(), s_readableByteStreamInternalsReadableStreamReaderKindCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamInternalsReadableStreamTeeCode, readableStreamTee, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCode, readableStreamTeeBranch1CancelFunction, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCode, readableStreamTeeBranch2CancelFunction, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsReadableStreamTeePullFunctionCode, readableStreamTeePullFunction, ASCIILiteral(), s_readableStreamInternalsReadableStreamTeePullFunctionCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamReadableStreamToArrayCode, readableStreamToArray, ASCIILiteral(), s_readableStreamReadableStreamToArrayCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamReadableStreamToArrayPublicCode, readableStreamToArrayPublic, ASCIILiteral(), s_readableStreamReadableStreamToArrayPublicCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamReadableStreamToBlobCode, readableStreamToBlob, ASCIILiteral(), s_readableStreamReadableStreamToBlobCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamReadableStreamToJSONCode, readableStreamToJSON, ASCIILiteral(), s_readableStreamReadableStreamToJSONCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamReadableStreamToTextCode, readableStreamToText, ASCIILiteral(), s_readableStreamReadableStreamToTextCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDefaultWriterReadyCode, ready, "get ready"_s, s_writableStreamDefaultWriterReadyCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamBYOBReaderReleaseLockCode, releaseLock, ASCIILiteral(), s_readableStreamBYOBReaderReleaseLockCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamDefaultReaderReleaseLockCode, releaseLock, ASCIILiteral(), s_readableStreamDefaultReaderReleaseLockCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamDefaultWriterReleaseLockCode, releaseLock, ASCIILiteral(), s_writableStreamDefaultWriterReleaseLockCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsZigGlobalObjectRequireCode, require, ASCIILiteral(), s_jsZigGlobalObjectRequireCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(streamInternalsResetQueueCode, resetQueue, ASCIILiteral(), s_streamInternalsResetQueueCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamBYOBRequestRespondCode, respond, ASCIILiteral(), s_readableStreamBYOBRequestRespondCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamBYOBRequestRespondWithNewViewCode, respondWithNewView, ASCIILiteral(), s_readableStreamBYOBRequestRespondWithNewViewCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeSetBigUint64Code, setBigUint64, ASCIILiteral(), s_jsBufferPrototypeSetBigUint64CodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamInternalsSetUpTransformStreamDefaultControllerCode, setUpTransformStreamDefaultController, ASCIILiteral(), s_transformStreamInternalsSetUpTransformStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(transformStreamInternalsSetUpTransformStreamDefaultControllerFromTransformerCode, setUpTransformStreamDefaultControllerFromTransformer, ASCIILiteral(), s_transformStreamInternalsSetUpTransformStreamDefaultControllerFromTransformerCodeLength)                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsSetUpWritableStreamDefaultControllerCode, setUpWritableStreamDefaultController, ASCIILiteral(), s_writableStreamInternalsSetUpWritableStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsSetUpWritableStreamDefaultControllerFromUnderlyingSinkCode, setUpWritableStreamDefaultControllerFromUnderlyingSink, ASCIILiteral(), s_writableStreamInternalsSetUpWritableStreamDefaultControllerFromUnderlyingSinkCodeLength)                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsSetUpWritableStreamDefaultWriterCode, setUpWritableStreamDefaultWriter, ASCIILiteral(), s_writableStreamInternalsSetUpWritableStreamDefaultWriterCodeLength)                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamInternalsSetupReadableStreamDefaultControllerCode, setupReadableStreamDefaultController, ASCIILiteral(), s_readableStreamInternalsSetupReadableStreamDefaultControllerCodeLength)                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(streamInternalsShieldingPromiseResolveCode, shieldingPromiseResolve, ASCIILiteral(), s_streamInternalsShieldingPromiseResolveCodeLength)                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(byteLengthQueuingStrategySizeCode, size, ASCIILiteral(), s_byteLengthQueuingStrategySizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(countQueuingStrategySizeCode, size, ASCIILiteral(), s_countQueuingStrategySizeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeSliceCode, slice, ASCIILiteral(), s_jsBufferPrototypeSliceCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeSubarrayCode, subarray, ASCIILiteral(), s_jsBufferPrototypeSubarrayCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamTeeCode, tee, ASCIILiteral(), s_readableStreamTeeCodeLength)                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamDefaultControllerTerminateCode, terminate, ASCIILiteral(), s_transformStreamDefaultControllerTerminateCodeLength)                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(streamInternalsToDictionaryCode, toDictionary, ASCIILiteral(), s_streamInternalsToDictionaryCodeLength)                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeToJSONCode, toJSON, ASCIILiteral(), s_jsBufferPrototypeToJSONCodeLength)                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamInternalsTransferBufferToCurrentRealmCode, transferBufferToCurrentRealm, ASCIILiteral(), s_readableByteStreamInternalsTransferBufferToCurrentRealmCodeLength)                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamInternalsTransformStreamDefaultControllerClearAlgorithmsCode, transformStreamDefaultControllerClearAlgorithms, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerClearAlgorithmsCodeLength)                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(transformStreamInternalsTransformStreamDefaultControllerEnqueueCode, transformStreamDefaultControllerEnqueue, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerEnqueueCodeLength)                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(transformStreamInternalsTransformStreamDefaultControllerErrorCode, transformStreamDefaultControllerError, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerErrorCodeLength)                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(transformStreamInternalsTransformStreamDefaultControllerPerformTransformCode, transformStreamDefaultControllerPerformTransform, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeLength)                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamInternalsTransformStreamDefaultControllerTerminateCode, transformStreamDefaultControllerTerminate, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultControllerTerminateCodeLength)                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(transformStreamInternalsTransformStreamDefaultSinkAbortAlgorithmCode, transformStreamDefaultSinkAbortAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSinkAbortAlgorithmCodeLength)                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCode, transformStreamDefaultSinkCloseAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeLength)                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCode, transformStreamDefaultSinkWriteAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeLength)                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamInternalsTransformStreamDefaultSourcePullAlgorithmCode, transformStreamDefaultSourcePullAlgorithm, ASCIILiteral(), s_transformStreamInternalsTransformStreamDefaultSourcePullAlgorithmCodeLength)                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(transformStreamInternalsTransformStreamErrorCode, transformStreamError, ASCIILiteral(), s_transformStreamInternalsTransformStreamErrorCodeLength)                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(transformStreamInternalsTransformStreamErrorWritableAndUnblockWriteCode, transformStreamErrorWritableAndUnblockWrite, ASCIILiteral(), s_transformStreamInternalsTransformStreamErrorWritableAndUnblockWriteCodeLength)                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(transformStreamInternalsTransformStreamSetBackpressureCode, transformStreamSetBackpressure, ASCIILiteral(), s_transformStreamInternalsTransformStreamSetBackpressureCodeLength)                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeUcs2SliceCode, ucs2Slice, ASCIILiteral(), s_jsBufferPrototypeUcs2SliceCodeLength)                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeUcs2WriteCode, ucs2Write, ASCIILiteral(), s_jsBufferPrototypeUcs2WriteCodeLength)                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeUtf16leSliceCode, utf16leSlice, ASCIILiteral(), s_jsBufferPrototypeUtf16leSliceCodeLength)                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeUtf16leWriteCode, utf16leWrite, ASCIILiteral(), s_jsBufferPrototypeUtf16leWriteCodeLength)                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeUtf8SliceCode, utf8Slice, ASCIILiteral(), s_jsBufferPrototypeUtf8SliceCodeLength)                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeUtf8WriteCode, utf8Write, ASCIILiteral(), s_jsBufferPrototypeUtf8WriteCodeLength)                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(streamInternalsValidateAndNormalizeQueuingStrategyCode, validateAndNormalizeQueuingStrategy, ASCIILiteral(), s_streamInternalsValidateAndNormalizeQueuingStrategyCodeLength)                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamBYOBRequestViewCode, view, "get view"_s, s_readableStreamBYOBRequestViewCodeLength)                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamWritableCode, writable, ASCIILiteral(), s_transformStreamWritableCodeLength)                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamAbortCode, writableStreamAbort, ASCIILiteral(), s_writableStreamInternalsWritableStreamAbortCodeLength)                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamAbortForBindingsCode, writableStreamAbortForBindings, ASCIILiteral(), s_writableStreamInternalsWritableStreamAbortForBindingsCodeLength)                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamAddWriteRequestCode, writableStreamAddWriteRequest, ASCIILiteral(), s_writableStreamInternalsWritableStreamAddWriteRequestCodeLength)                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamCloseCode, writableStreamClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamCloseCodeLength)                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamCloseForBindingsCode, writableStreamCloseForBindings, ASCIILiteral(), s_writableStreamInternalsWritableStreamCloseForBindingsCodeLength)                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamCloseQueuedOrInFlightCode, writableStreamCloseQueuedOrInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamCloseQueuedOrInFlightCodeLength)                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamDealWithRejectionCode, writableStreamDealWithRejection, ASCIILiteral(), s_writableStreamInternalsWritableStreamDealWithRejectionCodeLength)                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamDefaultControllerAdvanceQueueIfNeededCode, writableStreamDefaultControllerAdvanceQueueIfNeeded, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerAdvanceQueueIfNeededCodeLength)                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamDefaultControllerClearAlgorithmsCode, writableStreamDefaultControllerClearAlgorithms, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerClearAlgorithmsCodeLength)                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamDefaultControllerCloseCode, writableStreamDefaultControllerClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerCloseCodeLength)                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamDefaultControllerErrorCode, writableStreamDefaultControllerError, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerErrorCodeLength)                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamDefaultControllerErrorIfNeededCode, writableStreamDefaultControllerErrorIfNeeded, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerErrorIfNeededCodeLength)                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamDefaultControllerGetBackpressureCode, writableStreamDefaultControllerGetBackpressure, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerGetBackpressureCodeLength)                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamDefaultControllerGetChunkSizeCode, writableStreamDefaultControllerGetChunkSize, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerGetChunkSizeCodeLength)                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamDefaultControllerGetDesiredSizeCode, writableStreamDefaultControllerGetDesiredSize, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerGetDesiredSizeCodeLength)                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamDefaultControllerProcessCloseCode, writableStreamDefaultControllerProcessClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerProcessCloseCodeLength)                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamDefaultControllerProcessWriteCode, writableStreamDefaultControllerProcessWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerProcessWriteCodeLength)                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamDefaultControllerStartCode, writableStreamDefaultControllerStart, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerStartCodeLength)                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamDefaultControllerWriteCode, writableStreamDefaultControllerWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultControllerWriteCodeLength)                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamDefaultWriterAbortCode, writableStreamDefaultWriterAbort, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterAbortCodeLength)                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamDefaultWriterCloseCode, writableStreamDefaultWriterClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterCloseCodeLength)                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamDefaultWriterCloseWithErrorPropagationCode, writableStreamDefaultWriterCloseWithErrorPropagation, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterCloseWithErrorPropagationCodeLength)                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamDefaultWriterEnsureClosedPromiseRejectedCode, writableStreamDefaultWriterEnsureClosedPromiseRejected, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterEnsureClosedPromiseRejectedCodeLength)                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamDefaultWriterEnsureReadyPromiseRejectedCode, writableStreamDefaultWriterEnsureReadyPromiseRejected, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterEnsureReadyPromiseRejectedCodeLength)                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamDefaultWriterGetDesiredSizeCode, writableStreamDefaultWriterGetDesiredSize, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterGetDesiredSizeCodeLength)                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamDefaultWriterReleaseCode, writableStreamDefaultWriterRelease, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterReleaseCodeLength)                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamDefaultWriterWriteCode, writableStreamDefaultWriterWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamDefaultWriterWriteCodeLength)                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamFinishErroringCode, writableStreamFinishErroring, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishErroringCodeLength)                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamFinishInFlightCloseCode, writableStreamFinishInFlightClose, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightCloseCodeLength)                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamFinishInFlightCloseWithErrorCode, writableStreamFinishInFlightCloseWithError, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightCloseWithErrorCodeLength)                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamFinishInFlightWriteCode, writableStreamFinishInFlightWrite, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightWriteCodeLength)                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamFinishInFlightWriteWithErrorCode, writableStreamFinishInFlightWriteWithError, ASCIILiteral(), s_writableStreamInternalsWritableStreamFinishInFlightWriteWithErrorCodeLength)                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamHasOperationMarkedInFlightCode, writableStreamHasOperationMarkedInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamHasOperationMarkedInFlightCodeLength)                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamMarkCloseRequestInFlightCode, writableStreamMarkCloseRequestInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamMarkCloseRequestInFlightCodeLength)                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamInternalsWritableStreamMarkFirstWriteRequestInFlightCode, writableStreamMarkFirstWriteRequestInFlight, ASCIILiteral(), s_writableStreamInternalsWritableStreamMarkFirstWriteRequestInFlightCodeLength)                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamInternalsWritableStreamRejectCloseAndClosedPromiseIfNeededCode, writableStreamRejectCloseAndClosedPromiseIfNeeded, ASCIILiteral(), s_writableStreamInternalsWritableStreamRejectCloseAndClosedPromiseIfNeededCodeLength) \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamInternalsWritableStreamStartErroringCode, writableStreamStartErroring, ASCIILiteral(), s_writableStreamInternalsWritableStreamStartErroringCodeLength)                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamInternalsWritableStreamUpdateBackpressureCode, writableStreamUpdateBackpressure, ASCIILiteral(), s_writableStreamInternalsWritableStreamUpdateBackpressureCodeLength)                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDefaultWriterWriteCode, write, ASCIILiteral(), s_writableStreamDefaultWriterWriteCodeLength)                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeWriteBigInt64BECode, writeBigInt64BE, ASCIILiteral(), s_jsBufferPrototypeWriteBigInt64BECodeLength)                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeWriteBigInt64LECode, writeBigInt64LE, ASCIILiteral(), s_jsBufferPrototypeWriteBigInt64LECodeLength)                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeWriteBigUInt64BECode, writeBigUInt64BE, ASCIILiteral(), s_jsBufferPrototypeWriteBigUInt64BECodeLength)                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeWriteBigUInt64LECode, writeBigUInt64LE, ASCIILiteral(), s_jsBufferPrototypeWriteBigUInt64LECodeLength)                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeWriteDoubleBECode, writeDoubleBE, ASCIILiteral(), s_jsBufferPrototypeWriteDoubleBECodeLength)                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeWriteDoubleLECode, writeDoubleLE, ASCIILiteral(), s_jsBufferPrototypeWriteDoubleLECodeLength)                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeWriteFloatBECode, writeFloatBE, ASCIILiteral(), s_jsBufferPrototypeWriteFloatBECodeLength)                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeWriteFloatLECode, writeFloatLE, ASCIILiteral(), s_jsBufferPrototypeWriteFloatLECodeLength)                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeWriteInt16BECode, writeInt16BE, ASCIILiteral(), s_jsBufferPrototypeWriteInt16BECodeLength)                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeWriteInt16LECode, writeInt16LE, ASCIILiteral(), s_jsBufferPrototypeWriteInt16LECodeLength)                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeWriteInt32BECode, writeInt32BE, ASCIILiteral(), s_jsBufferPrototypeWriteInt32BECodeLength)                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeWriteInt32LECode, writeInt32LE, ASCIILiteral(), s_jsBufferPrototypeWriteInt32LECodeLength)                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeWriteInt8Code, writeInt8, ASCIILiteral(), s_jsBufferPrototypeWriteInt8CodeLength)                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeWriteUInt16BECode, writeUInt16BE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt16BECodeLength)                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(jsBufferPrototypeWriteUInt16LECode, writeUInt16LE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt16LECodeLength)                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(jsBufferPrototypeWriteUInt32BECode, writeUInt32BE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt32BECodeLength)                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(jsBufferPrototypeWriteUInt32LECode, writeUInt32LE, ASCIILiteral(), s_jsBufferPrototypeWriteUInt32LECodeLength)                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(jsBufferPrototypeWriteUInt8Code, writeUInt8, ASCIILiteral(), s_jsBufferPrototypeWriteUInt8CodeLength)
 
-#define WEBCORE_FOREACH_BUILTIN_FUNCTION_NAME(macro) \
-    macro(abort) \
-    macro(acquireReadableStreamDefaultReader) \
-    macro(acquireWritableStreamDefaultWriter) \
-    macro(asciiSlice) \
-    macro(asciiWrite) \
-    macro(assignDirectStream) \
-    macro(base64Slice) \
-    macro(base64Write) \
-    macro(base64urlSlice) \
-    macro(base64urlWrite) \
-    macro(byobRequest) \
-    macro(cancel) \
-    macro(close) \
-    macro(closed) \
-    macro(consumeReadableStream) \
-    macro(createEmptyReadableStream) \
-    macro(createFIFO) \
-    macro(createFulfilledPromise) \
-    macro(createInternalWritableStreamFromUnderlyingSink) \
-    macro(createNativeReadableStream) \
-    macro(createReadableStreamController) \
-    macro(createTransformStream) \
-    macro(createWritableStream) \
-    macro(dequeueValue) \
-    macro(desiredSize) \
-    macro(enqueue) \
-    macro(enqueueValueWithSize) \
-    macro(error) \
-    macro(extractHighWaterMark) \
-    macro(extractHighWaterMarkFromQueuingStrategyInit) \
-    macro(extractSizeAlgorithm) \
-    macro(from) \
-    macro(getReader) \
-    macro(handleDirectStreamError) \
-    macro(handleDirectStreamErrorReject) \
-    macro(hexSlice) \
-    macro(hexWrite) \
-    macro(highWaterMark) \
-    macro(initializeArrayBufferStream) \
-    macro(initializeBunBuffer) \
-    macro(initializeByteLengthQueuingStrategy) \
-    macro(initializeCountQueuingStrategy) \
-    macro(initializeReadableByteStreamController) \
-    macro(initializeReadableStream) \
-    macro(initializeReadableStreamBYOBReader) \
-    macro(initializeReadableStreamBYOBRequest) \
-    macro(initializeReadableStreamDefaultController) \
-    macro(initializeReadableStreamDefaultReader) \
-    macro(initializeTransformStream) \
-    macro(initializeTransformStreamDefaultController) \
-    macro(initializeWritableStreamDefaultController) \
-    macro(initializeWritableStreamDefaultWriter) \
-    macro(initializeWritableStreamSlots) \
-    macro(isCloseSentinel) \
-    macro(isReadableByteStreamController) \
-    macro(isReadableStream) \
-    macro(isReadableStreamBYOBReader) \
-    macro(isReadableStreamBYOBRequest) \
-    macro(isReadableStreamDefaultController) \
-    macro(isReadableStreamDefaultReader) \
-    macro(isReadableStreamDisturbed) \
-    macro(isReadableStreamLocked) \
-    macro(isTransformStream) \
-    macro(isTransformStreamDefaultController) \
-    macro(isWritableStream) \
-    macro(isWritableStreamDefaultWriter) \
-    macro(isWritableStreamLocked) \
-    macro(latin1Slice) \
-    macro(latin1Write) \
-    macro(lazyLoadStream) \
-    macro(locked) \
-    macro(markPromiseAsHandled) \
-    macro(newQueue) \
-    macro(noopDoneFunction) \
-    macro(onCloseDirectStream) \
-    macro(onDrainDirectStream) \
-    macro(onPullDirectStream) \
-    macro(onReadableStreamDirectControllerClosed) \
-    macro(peekQueueValue) \
-    macro(pipeThrough) \
-    macro(pipeTo) \
-    macro(pipeToClosingMustBePropagatedBackward) \
-    macro(pipeToClosingMustBePropagatedForward) \
-    macro(pipeToDoReadWrite) \
-    macro(pipeToErrorsMustBePropagatedBackward) \
-    macro(pipeToErrorsMustBePropagatedForward) \
-    macro(pipeToFinalize) \
-    macro(pipeToLoop) \
-    macro(pipeToShutdown) \
-    macro(pipeToShutdownWithAction) \
-    macro(privateInitializeReadableByteStreamController) \
-    macro(privateInitializeReadableStreamBYOBRequest) \
-    macro(privateInitializeReadableStreamDefaultController) \
-    macro(promiseInvokeOrFallbackOrNoop) \
-    macro(promiseInvokeOrNoop) \
-    macro(promiseInvokeOrNoopMethod) \
-    macro(promiseInvokeOrNoopMethodNoCatch) \
-    macro(promiseInvokeOrNoopNoCatch) \
-    macro(read) \
-    macro(readBigInt64BE) \
-    macro(readBigInt64LE) \
-    macro(readBigUInt64BE) \
-    macro(readBigUInt64LE) \
-    macro(readDoubleBE) \
-    macro(readDoubleLE) \
-    macro(readFloatBE) \
-    macro(readFloatLE) \
-    macro(readInt16BE) \
-    macro(readInt16LE) \
-    macro(readInt32BE) \
-    macro(readInt32LE) \
-    macro(readInt8) \
-    macro(readMany) \
-    macro(readUInt16BE) \
-    macro(readUInt16LE) \
-    macro(readUInt32BE) \
-    macro(readUInt32LE) \
-    macro(readUInt8) \
-    macro(readable) \
-    macro(readableByteStreamControllerCallPullIfNeeded) \
-    macro(readableByteStreamControllerCancel) \
-    macro(readableByteStreamControllerClearPendingPullIntos) \
-    macro(readableByteStreamControllerClose) \
-    macro(readableByteStreamControllerCommitDescriptor) \
-    macro(readableByteStreamControllerConvertDescriptor) \
-    macro(readableByteStreamControllerEnqueue) \
-    macro(readableByteStreamControllerEnqueueChunk) \
-    macro(readableByteStreamControllerError) \
-    macro(readableByteStreamControllerFillDescriptorFromQueue) \
-    macro(readableByteStreamControllerGetDesiredSize) \
-    macro(readableByteStreamControllerHandleQueueDrain) \
-    macro(readableByteStreamControllerInvalidateBYOBRequest) \
-    macro(readableByteStreamControllerProcessPullDescriptors) \
-    macro(readableByteStreamControllerPull) \
-    macro(readableByteStreamControllerPullInto) \
-    macro(readableByteStreamControllerRespond) \
-    macro(readableByteStreamControllerRespondInClosedState) \
-    macro(readableByteStreamControllerRespondInReadableState) \
-    macro(readableByteStreamControllerRespondInternal) \
-    macro(readableByteStreamControllerRespondWithNewView) \
-    macro(readableByteStreamControllerShiftPendingDescriptor) \
-    macro(readableByteStreamControllerShouldCallPull) \
-    macro(readableStreamAddReadIntoRequest) \
-    macro(readableStreamAddReadRequest) \
-    macro(readableStreamBYOBReaderRead) \
-    macro(readableStreamByteStreamControllerStart) \
-    macro(readableStreamCancel) \
-    macro(readableStreamClose) \
-    macro(readableStreamDefaultControllerCallPullIfNeeded) \
-    macro(readableStreamDefaultControllerCanCloseOrEnqueue) \
-    macro(readableStreamDefaultControllerCancel) \
-    macro(readableStreamDefaultControllerClose) \
-    macro(readableStreamDefaultControllerEnqueue) \
-    macro(readableStreamDefaultControllerError) \
-    macro(readableStreamDefaultControllerGetDesiredSize) \
-    macro(readableStreamDefaultControllerPull) \
-    macro(readableStreamDefaultControllerShouldCallPull) \
-    macro(readableStreamDefaultControllerStart) \
-    macro(readableStreamDefaultReaderRead) \
-    macro(readableStreamError) \
-    macro(readableStreamFulfillReadIntoRequest) \
-    macro(readableStreamFulfillReadRequest) \
-    macro(readableStreamHasBYOBReader) \
-    macro(readableStreamHasDefaultReader) \
-    macro(readableStreamPipeTo) \
-    macro(readableStreamPipeToWritableStream) \
-    macro(readableStreamReaderGenericCancel) \
-    macro(readableStreamReaderGenericInitialize) \
-    macro(readableStreamReaderGenericRelease) \
-    macro(readableStreamReaderKind) \
-    macro(readableStreamTee) \
-    macro(readableStreamTeeBranch1CancelFunction) \
-    macro(readableStreamTeeBranch2CancelFunction) \
-    macro(readableStreamTeePullFunction) \
-    macro(readableStreamToArray) \
-    macro(readableStreamToArrayPublic) \
-    macro(readableStreamToBlob) \
-    macro(readableStreamToJSON) \
-    macro(readableStreamToText) \
-    macro(ready) \
-    macro(releaseLock) \
-    macro(require) \
-    macro(resetQueue) \
-    macro(respond) \
-    macro(respondWithNewView) \
-    macro(setBigUint64) \
-    macro(setUpTransformStreamDefaultController) \
-    macro(setUpTransformStreamDefaultControllerFromTransformer) \
-    macro(setUpWritableStreamDefaultController) \
-    macro(setUpWritableStreamDefaultControllerFromUnderlyingSink) \
-    macro(setUpWritableStreamDefaultWriter) \
-    macro(setupReadableStreamDefaultController) \
-    macro(shieldingPromiseResolve) \
-    macro(size) \
-    macro(slice) \
-    macro(subarray) \
-    macro(tee) \
-    macro(terminate) \
-    macro(toDictionary) \
-    macro(toJSON) \
-    macro(transferBufferToCurrentRealm) \
-    macro(transformStreamDefaultControllerClearAlgorithms) \
-    macro(transformStreamDefaultControllerEnqueue) \
-    macro(transformStreamDefaultControllerError) \
-    macro(transformStreamDefaultControllerPerformTransform) \
-    macro(transformStreamDefaultControllerTerminate) \
-    macro(transformStreamDefaultSinkAbortAlgorithm) \
-    macro(transformStreamDefaultSinkCloseAlgorithm) \
-    macro(transformStreamDefaultSinkWriteAlgorithm) \
-    macro(transformStreamDefaultSourcePullAlgorithm) \
-    macro(transformStreamError) \
-    macro(transformStreamErrorWritableAndUnblockWrite) \
-    macro(transformStreamSetBackpressure) \
-    macro(ucs2Slice) \
-    macro(ucs2Write) \
-    macro(utf16leSlice) \
-    macro(utf16leWrite) \
-    macro(utf8Slice) \
-    macro(utf8Write) \
-    macro(validateAndNormalizeQueuingStrategy) \
-    macro(view) \
-    macro(writable) \
-    macro(writableStreamAbort) \
-    macro(writableStreamAbortForBindings) \
-    macro(writableStreamAddWriteRequest) \
-    macro(writableStreamClose) \
-    macro(writableStreamCloseForBindings) \
-    macro(writableStreamCloseQueuedOrInFlight) \
-    macro(writableStreamDealWithRejection) \
-    macro(writableStreamDefaultControllerAdvanceQueueIfNeeded) \
-    macro(writableStreamDefaultControllerClearAlgorithms) \
-    macro(writableStreamDefaultControllerClose) \
-    macro(writableStreamDefaultControllerError) \
-    macro(writableStreamDefaultControllerErrorIfNeeded) \
-    macro(writableStreamDefaultControllerGetBackpressure) \
-    macro(writableStreamDefaultControllerGetChunkSize) \
-    macro(writableStreamDefaultControllerGetDesiredSize) \
-    macro(writableStreamDefaultControllerProcessClose) \
-    macro(writableStreamDefaultControllerProcessWrite) \
-    macro(writableStreamDefaultControllerStart) \
-    macro(writableStreamDefaultControllerWrite) \
-    macro(writableStreamDefaultWriterAbort) \
-    macro(writableStreamDefaultWriterClose) \
-    macro(writableStreamDefaultWriterCloseWithErrorPropagation) \
-    macro(writableStreamDefaultWriterEnsureClosedPromiseRejected) \
-    macro(writableStreamDefaultWriterEnsureReadyPromiseRejected) \
-    macro(writableStreamDefaultWriterGetDesiredSize) \
-    macro(writableStreamDefaultWriterRelease) \
-    macro(writableStreamDefaultWriterWrite) \
-    macro(writableStreamFinishErroring) \
-    macro(writableStreamFinishInFlightClose) \
-    macro(writableStreamFinishInFlightCloseWithError) \
-    macro(writableStreamFinishInFlightWrite) \
-    macro(writableStreamFinishInFlightWriteWithError) \
-    macro(writableStreamHasOperationMarkedInFlight) \
-    macro(writableStreamMarkCloseRequestInFlight) \
-    macro(writableStreamMarkFirstWriteRequestInFlight) \
-    macro(writableStreamRejectCloseAndClosedPromiseIfNeeded) \
-    macro(writableStreamStartErroring) \
-    macro(writableStreamUpdateBackpressure) \
-    macro(write) \
-    macro(writeBigInt64BE) \
-    macro(writeBigInt64LE) \
-    macro(writeBigUInt64BE) \
-    macro(writeBigUInt64LE) \
-    macro(writeDoubleBE) \
-    macro(writeDoubleLE) \
-    macro(writeFloatBE) \
-    macro(writeFloatLE) \
-    macro(writeInt16BE) \
-    macro(writeInt16LE) \
-    macro(writeInt32BE) \
-    macro(writeInt32LE) \
-    macro(writeInt8) \
-    macro(writeUInt16BE) \
-    macro(writeUInt16LE) \
-    macro(writeUInt32BE) \
-    macro(writeUInt32LE) \
-    macro(writeUInt8) \
+#define WEBCORE_FOREACH_BUILTIN_FUNCTION_NAME(macro)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+    macro(abort)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+        macro(acquireReadableStreamDefaultReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+            macro(acquireWritableStreamDefaultWriter)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                macro(asciiSlice)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                    macro(asciiWrite)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                        macro(assignToStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                            macro(base64Slice)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                macro(base64Write)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                    macro(base64urlSlice)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                        macro(base64urlWrite)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                            macro(byobRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                macro(cancel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                    macro(close)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                        macro(closed)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                            macro(consumeReadableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                macro(createEmptyReadableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                    macro(createFIFO)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                        macro(createFulfilledPromise)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                            macro(createInternalWritableStreamFromUnderlyingSink)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                macro(createNativeReadableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                    macro(createReadableStreamController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                        macro(createTransformStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                            macro(createWritableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                macro(dequeueValue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                    macro(desiredSize)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                        macro(enqueue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                            macro(enqueueValueWithSize)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                macro(error)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                    macro(extractHighWaterMark)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                        macro(extractHighWaterMarkFromQueuingStrategyInit)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                            macro(extractSizeAlgorithm)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                macro(from)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                    macro(getReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                        macro(handleDirectStreamError)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                            macro(handleDirectStreamErrorReject)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                macro(hexSlice)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                    macro(hexWrite)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                        macro(highWaterMark)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                            macro(initializeArrayBufferStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                macro(initializeBunBuffer)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                    macro(initializeByteLengthQueuingStrategy)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                        macro(initializeCountQueuingStrategy)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                            macro(initializeReadableByteStreamController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                macro(initializeReadableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                    macro(initializeReadableStreamBYOBReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                        macro(initializeReadableStreamBYOBRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                            macro(initializeReadableStreamDefaultController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                macro(initializeReadableStreamDefaultReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                    macro(initializeTransformStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                        macro(initializeTransformStreamDefaultController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                            macro(initializeWritableStreamDefaultController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                macro(initializeWritableStreamDefaultWriter)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                    macro(initializeWritableStreamSlots)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                        macro(isCloseSentinel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                            macro(isReadableByteStreamController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                macro(isReadableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                    macro(isReadableStreamBYOBReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                        macro(isReadableStreamBYOBRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                            macro(isReadableStreamDefaultController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                macro(isReadableStreamDefaultReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                    macro(isReadableStreamDisturbed)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                        macro(isReadableStreamLocked)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                            macro(isTransformStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                macro(isTransformStreamDefaultController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                    macro(isWritableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                        macro(isWritableStreamDefaultWriter)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                            macro(isWritableStreamLocked)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                macro(latin1Slice)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                    macro(latin1Write)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                        macro(lazyLoadStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                            macro(locked)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                macro(markPromiseAsHandled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                    macro(newQueue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                        macro(noopDoneFunction)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                            macro(onCloseDirectStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                macro(onDrainDirectStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                    macro(onPullDirectStream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                        macro(onReadableStreamDirectControllerClosed)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                            macro(peekQueueValue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                macro(pipeThrough)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                    macro(pipeTo)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                        macro(pipeToClosingMustBePropagatedBackward)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                            macro(pipeToClosingMustBePropagatedForward)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                macro(pipeToDoReadWrite)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                    macro(pipeToErrorsMustBePropagatedBackward)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                        macro(pipeToErrorsMustBePropagatedForward)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                            macro(pipeToFinalize)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                macro(pipeToLoop)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                    macro(pipeToShutdown)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                        macro(pipeToShutdownWithAction)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                            macro(privateInitializeReadableByteStreamController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                macro(privateInitializeReadableStreamBYOBRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                    macro(privateInitializeReadableStreamDefaultController)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                        macro(promiseInvokeOrFallbackOrNoop)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                            macro(promiseInvokeOrNoop)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                macro(promiseInvokeOrNoopMethod)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                    macro(promiseInvokeOrNoopMethodNoCatch)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                        macro(promiseInvokeOrNoopNoCatch)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                            macro(read)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                macro(readBigInt64BE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readBigInt64LE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readBigUInt64BE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readBigUInt64LE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readDoubleBE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readDoubleLE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readFloatBE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readFloatLE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readInt16BE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readInt16LE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readInt32BE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readInt32LE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readInt8)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readMany)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readUInt16BE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readUInt16LE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readUInt32BE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readUInt32LE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readUInt8)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readable)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamControllerCallPullIfNeeded)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamControllerCancel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamControllerClearPendingPullIntos)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamControllerClose)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamControllerCommitDescriptor)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamControllerConvertDescriptor)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamControllerEnqueue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamControllerEnqueueChunk)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamControllerError)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamControllerFillDescriptorFromQueue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamControllerGetDesiredSize)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamControllerHandleQueueDrain)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamControllerInvalidateBYOBRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamControllerProcessPullDescriptors)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamControllerPull)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamControllerPullInto)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamControllerRespond)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamControllerRespondInClosedState)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamControllerRespondInReadableState)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableByteStreamControllerRespondInternal)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableByteStreamControllerRespondWithNewView)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableByteStreamControllerShiftPendingDescriptor)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableByteStreamControllerShouldCallPull)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamAddReadIntoRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamAddReadRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamBYOBReaderRead)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamByteStreamControllerStart)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamCancel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamClose)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamDefaultControllerCallPullIfNeeded)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamDefaultControllerCanCloseOrEnqueue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamDefaultControllerCancel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamDefaultControllerClose)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamDefaultControllerEnqueue)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamDefaultControllerError)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamDefaultControllerGetDesiredSize)                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamDefaultControllerPull)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamDefaultControllerShouldCallPull)                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamDefaultControllerStart)                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamDefaultReaderRead)                                                                                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamError)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamFulfillReadIntoRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamFulfillReadRequest)                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamHasBYOBReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamHasDefaultReader)                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamPipeTo)                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamPipeToWritableStream)                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamReaderGenericCancel)                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamReaderGenericInitialize)                                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamReaderGenericRelease)                                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamReaderKind)                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamTee)                                                                                                                                                                                                                                                                                                                                                                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamTeeBranch1CancelFunction)                                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamTeeBranch2CancelFunction)                                                                                                                                                                                                                                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamTeePullFunction)                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamToArray)                                                                                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(readableStreamToArrayPublic)                                                                                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(readableStreamToBlob)                                                                                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(readableStreamToJSON)                                                                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(readableStreamToText)                                                                                                                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(ready)                                                                                                                                                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(releaseLock)                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(require)                                                                                                                                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(resetQueue)                                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(respond)                                                                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(respondWithNewView)                                                                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(setBigUint64)                                                                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(setUpTransformStreamDefaultController)                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(setUpTransformStreamDefaultControllerFromTransformer)                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(setUpWritableStreamDefaultController)                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(setUpWritableStreamDefaultControllerFromUnderlyingSink)                                                                                                                                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(setUpWritableStreamDefaultWriter)                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(setupReadableStreamDefaultController)                                                                                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(shieldingPromiseResolve)                                                                                                                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(size)                                                                                                                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(slice)                                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(subarray)                                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(tee)                                                                                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(terminate)                                                                                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(toDictionary)                                                                                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(toJSON)                                                                                                                                                                                                                                                                                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(transferBufferToCurrentRealm)                                                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamDefaultControllerClearAlgorithms)                                                                                                                                                                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(transformStreamDefaultControllerEnqueue)                                                                                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(transformStreamDefaultControllerError)                                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(transformStreamDefaultControllerPerformTransform)                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamDefaultControllerTerminate)                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(transformStreamDefaultSinkAbortAlgorithm)                                                                                                                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(transformStreamDefaultSinkCloseAlgorithm)                                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(transformStreamDefaultSinkWriteAlgorithm)                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(transformStreamDefaultSourcePullAlgorithm)                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(transformStreamError)                                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(transformStreamErrorWritableAndUnblockWrite)                                                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(transformStreamSetBackpressure)                                                                                                                                                                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(ucs2Slice)                                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(ucs2Write)                                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(utf16leSlice)                                                                                                                                                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(utf16leWrite)                                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(utf8Slice)                                                                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(utf8Write)                                                                                                                                                                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(validateAndNormalizeQueuingStrategy)                                                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(view)                                                                                                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writable)                                                                                                                                                                                                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamAbort)                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamAbortForBindings)                                                                                                                                                                                                        \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamAddWriteRequest)                                                                                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamClose)                                                                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamCloseForBindings)                                                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamCloseQueuedOrInFlight)                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDealWithRejection)                                                                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamDefaultControllerAdvanceQueueIfNeeded)                                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamDefaultControllerClearAlgorithms)                                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamDefaultControllerClose)                                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDefaultControllerError)                                                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamDefaultControllerErrorIfNeeded)                                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamDefaultControllerGetBackpressure)                                                                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamDefaultControllerGetChunkSize)                                                                                                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDefaultControllerGetDesiredSize)                                                                                                                                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamDefaultControllerProcessClose)                                                                                                                                   \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamDefaultControllerProcessWrite)                                                                                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamDefaultControllerStart)                                                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDefaultControllerWrite)                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamDefaultWriterAbort)                                                                                                                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamDefaultWriterClose)                                                                                                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamDefaultWriterCloseWithErrorPropagation)                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDefaultWriterEnsureClosedPromiseRejected)                                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamDefaultWriterEnsureReadyPromiseRejected)                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamDefaultWriterGetDesiredSize)                                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamDefaultWriterRelease)                                                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamDefaultWriterWrite)                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamFinishErroring)                                                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamFinishInFlightClose)                                                                                         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamFinishInFlightCloseWithError)                                                                            \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamFinishInFlightWrite)                                                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamFinishInFlightWriteWithError)                                                                    \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamHasOperationMarkedInFlight)                                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamMarkCloseRequestInFlight)                                                                \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writableStreamMarkFirstWriteRequestInFlight)                                                       \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writableStreamRejectCloseAndClosedPromiseIfNeeded)                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writableStreamStartErroring)                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writableStreamUpdateBackpressure)                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(write)                                                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writeBigInt64BE)                                                               \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writeBigInt64LE)                                                           \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writeBigUInt64BE)                                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writeBigUInt64LE)                                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writeDoubleBE)                                                 \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writeDoubleLE)                                             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writeFloatBE)                                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writeFloatLE)                                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writeInt16BE)                                  \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writeInt16LE)                              \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writeInt32BE)                          \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writeInt32LE)                      \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writeInt8)                     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writeUInt16BE)             \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                macro(writeUInt16LE)         \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    macro(writeUInt32BE)     \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        macro(writeUInt32LE) \
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            macro(writeUInt8)
 
-#define WEBCORE_FOREACH_BUILTIN_FUNCTION_PRIVATE_GLOBAL_NAME(macro) \
-    macro(assignDirectStream, readableStreamInternalsAssignDirectStream) \
-    macro(consumeReadableStream, readableStreamConsumeReadableStream) \
-    macro(createEmptyReadableStream, readableStreamCreateEmptyReadableStream) \
-    macro(createFIFO, streamInternalsCreateFIFO) \
-    macro(createNativeReadableStream, readableStreamCreateNativeReadableStream) \
-    macro(readableStreamToArray, readableStreamReadableStreamToArray) \
-    macro(readableStreamToArrayPublic, readableStreamReadableStreamToArrayPublic) \
-    macro(readableStreamToBlob, readableStreamReadableStreamToBlob) \
-    macro(readableStreamToJSON, readableStreamReadableStreamToJSON) \
-    macro(readableStreamToText, readableStreamReadableStreamToText) \
+#define WEBCORE_FOREACH_BUILTIN_FUNCTION_PRIVATE_GLOBAL_NAME(macro)                                       \
+    macro(assignToStream, readableStreamInternalsAssignDirectStream)                                      \
+        macro(consumeReadableStream, readableStreamConsumeReadableStream)                                 \
+            macro(createEmptyReadableStream, readableStreamCreateEmptyReadableStream)                     \
+                macro(createFIFO, streamInternalsCreateFIFO)                                              \
+                    macro(createNativeReadableStream, readableStreamCreateNativeReadableStream)           \
+                        macro(readableStreamToArray, readableStreamReadableStreamToArray)                 \
+                            macro(readableStreamToArrayPublic, readableStreamReadableStreamToArrayPublic) \
+                                macro(readableStreamToBlob, readableStreamReadableStreamToBlob)           \
+                                    macro(readableStreamToJSON, readableStreamReadableStreamToJSON)       \
+                                        macro(readableStreamToText, readableStreamReadableStreamToText)
 
 #define DECLARE_BUILTIN_GENERATOR(codeName, functionName, overriddenName, argumentCount) \
     JSC::FunctionExecutable* codeName##Generator(JSC::VM&);
diff --git a/src/bun.js/builtins/BunBuiltinNames.h b/src/bun.js/builtins/BunBuiltinNames.h
index c41d368b4..8cc0369b4 100644
--- a/src/bun.js/builtins/BunBuiltinNames.h
+++ b/src/bun.js/builtins/BunBuiltinNames.h
@@ -40,7 +40,7 @@ using namespace JSC;
     macro(addEventListener) \
     macro(appendFromJS) \
     macro(argv) \
-    macro(assignDirectStream) \
+    macro(assignToStream) \
     macro(associatedReadableByteStreamController) \
     macro(autoAllocateChunkSize) \
     macro(backpressure) \
diff --git a/src/bun.js/builtins/cpp/ReadableStreamBuiltins.cpp b/src/bun.js/builtins/cpp/ReadableStreamBuiltins.cpp
index 7ce97e7bb..2af23348e 100644
--- a/src/bun.js/builtins/cpp/ReadableStreamBuiltins.cpp
+++ b/src/bun.js/builtins/cpp/ReadableStreamBuiltins.cpp
@@ -49,7 +49,7 @@ namespace WebCore {
 
 const JSC::ConstructAbility s_readableStreamInitializeReadableStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInitializeReadableStreamCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamInitializeReadableStreamCodeLength = 2501;
+const int s_readableStreamInitializeReadableStreamCodeLength = 2783;
 static const JSC::Intrinsic s_readableStreamInitializeReadableStreamCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamInitializeReadableStreamCode =
     "(function (underlyingSource, strategy)\n" \
@@ -90,14 +90,17 @@ const char* const s_readableStreamInitializeReadableStreamCode =
     "    if (@getByIdDirectPrivate(underlyingSource, \"pull\") !== @undefined && !isLazy) {\n" \
     "        const size = @getByIdDirectPrivate(strategy, \"size\");\n" \
     "        const highWaterMark = @getByIdDirectPrivate(strategy, \"highWaterMark\");\n" \
+    "        @putByIdDirectPrivate(this, \"underlyingSource\", @undefined);\n" \
     "        @setupReadableStreamDefaultController(this, underlyingSource, size, highWaterMark !== @undefined ? highWaterMark : 1, @getByIdDirectPrivate(underlyingSource, \"start\"), @getByIdDirectPrivate(underlyingSource, \"pull\"), @getByIdDirectPrivate(underlyingSource, \"cancel\"));\n" \
     "        \n" \
     "        return this;\n" \
     "    }\n" \
     "    if (isDirect) {\n" \
+    "        @putByIdDirectPrivate(this, \"underlyingSource\", underlyingSource);\n" \
     "        @putByIdDirectPrivate(this, \"start\", () => @createReadableStreamController(this, underlyingSource, strategy));\n" \
     "    } else if (isLazy) {\n" \
     "        const autoAllocateChunkSize = underlyingSource.autoAllocateChunkSize;\n" \
+    "        @putByIdDirectPrivate(this, \"underlyingSource\", @undefined);\n" \
     "\n" \
     "        \n" \
     "        @putByIdDirectPrivate(this, \"start\", () => {\n" \
@@ -107,6 +110,7 @@ const char* const s_readableStreamInitializeReadableStreamCode =
     "            }\n" \
     "        });\n" \
     "    } else {\n" \
+    "        @putByIdDirectPrivate(this, \"underlyingSource\", @undefined);\n" \
     "        @putByIdDirectPrivate(this, \"start\", @undefined);\n" \
     "        @createReadableStreamController(this, underlyingSource, strategy);\n" \
     "    }\n" \
diff --git a/src/bun.js/builtins/cpp/ReadableStreamDefaultReaderBuiltins.cpp b/src/bun.js/builtins/cpp/ReadableStreamDefaultReaderBuiltins.cpp
index b1f8d4791..9a8935324 100644
--- a/src/bun.js/builtins/cpp/ReadableStreamDefaultReaderBuiltins.cpp
+++ b/src/bun.js/builtins/cpp/ReadableStreamDefaultReaderBuiltins.cpp
@@ -89,7 +89,7 @@ const char* const s_readableStreamDefaultReaderCancelCode =
 
 const JSC::ConstructAbility s_readableStreamDefaultReaderReadManyCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamDefaultReaderReadManyCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamDefaultReaderReadManyCodeLength = 3414;
+const int s_readableStreamDefaultReaderReadManyCodeLength = 3712;
 static const JSC::Intrinsic s_readableStreamDefaultReaderReadManyCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamDefaultReaderReadManyCode =
     "(function ()\n" \
@@ -128,6 +128,11 @@ const char* const s_readableStreamDefaultReaderReadManyCode =
     "                    value[i] = new @Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);\n" \
     "                }\n" \
     "            }\n" \
+    "        } else {\n" \
+    "            values[0] = values[0].value;\n" \
+    "            for (var i = 1; i < values.length; i++) {\n" \
+    "                values[i] = values[i].value;\n" \
+    "            }\n" \
     "        }\n" \
     "        \n" \
     "        @resetQueue(@getByIdDirectPrivate(controller, \"queue\"));\n" \
@@ -158,6 +163,10 @@ const char* const s_readableStreamDefaultReaderReadManyCode =
     "                    value[i] = new @Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);\n" \
     "                }\n" \
     "            }\n" \
+    "        } else {\n" \
+    "            for (var i = 1; i < value.length; i++) {\n" \
+    "                value[i] = value[i].value;\n" \
+    "            }\n" \
     "        }\n" \
     "        \n" \
     "        var size = queue.size;\n" \
diff --git a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp
index 09e96a121..ca82613a7 100644
--- a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp
+++ b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp
@@ -762,15 +762,111 @@ const char* const s_readableStreamInternalsIsReadableStreamDefaultControllerCode
     "})\n" \
 ;
 
-const JSC::ConstructAbility s_readableStreamInternalsAssignDirectStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
-const JSC::ConstructorKind s_readableStreamInternalsAssignDirectStreamCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamInternalsAssignDirectStreamCodeLength = 60;
-static const JSC::Intrinsic s_readableStreamInternalsAssignDirectStreamCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_readableStreamInternalsAssignDirectStreamCode =
-    "(function () {\n" \
+const JSC::ConstructAbility s_readableStreamInternalsAssignToStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
+const JSC::ConstructorKind s_readableStreamInternalsAssignToStreamCodeConstructorKind = JSC::ConstructorKind::None;
+const int s_readableStreamInternalsAssignToStreamCodeLength = 2534;
+static const JSC::Intrinsic s_readableStreamInternalsAssignToStreamCodeIntrinsic = JSC::NoIntrinsic;
+const char* const s_readableStreamInternalsAssignToStreamCode =
+    "(function (stream, sink) {\n" \
     "    \"use strict\";\n" \
     "\n" \
-    "    var stream = this;\n" \
+    "    //\n" \
+    "    const underlyingSource = @getByIdDirectPrivate(stream, \"underlyingSource\");\n" \
+    "\n" \
+    "    //\n" \
+    "    if (underlyingSource) {\n" \
+    "        var originalClose = underlyingSource.close;\n" \
+    "        var reader;\n" \
+    "        var close = (reason) => {\n" \
+    "            originalClose && originalClose(reason);\n" \
+    "            try {\n" \
+    "                reader && reader.releaseLock();\n" \
+    "            } catch (e) {}\n" \
+    "            @readableStreamClose(stream, reason);\n" \
+    "            \n" \
+    "        }\n" \
+    "        var pull = underlyingSource.pull;\n" \
+    "       \n" \
+    "        @putByIdDirectPrivate(stream, \"readableStreamController\", sink);\n" \
+    "        @putByIdDirectPrivate(stream, \"start\", @undefined);\n" \
+    "        @putByIdDirectPrivate(stream, \"underlyingSource\", @undefined);\n" \
+    "\n" \
+    "        @startDirectStream.@call(sink, stream, pull, close);\n" \
+    "\n" \
+    "        if (!pull) {\n" \
+    "            close();\n" \
+    "            return;\n" \
+    "        }\n" \
+    "\n" \
+    "        if (!@isCallable(pull)) {\n" \
+    "            close();\n" \
+    "            @throwTypeError(\"pull is not a function\");\n" \
+    "            return;\n" \
+    "        }\n" \
+    "\n" \
+    "        //\n" \
+    "        reader = stream.getReader();\n" \
+    "\n" \
+    "        pull(sink);\n" \
+    "        return;\n" \
+    "    }\n" \
+    "\n" \
+    "   \n" \
+    "    return (async function() {\n" \
+    "        \"use strict\";\n" \
+    "\n" \
+    "        var didClose = false;\n" \
+    "\n" \
+    "\n" \
+    "        try {\n" \
+    "            var reader = stream.getReader();\n" \
+    "            reader.closed.then(() => {\n" \
+    "                if (!didClose && sink) {\n" \
+    "                    didClose = true;\n" \
+    "                    sink.end();\n" \
+    "                }\n" \
+    "            }, (e) => {\n" \
+    "                if (!didClose && sink) {\n" \
+    "                    didClose = true;\n" \
+    "                    sink.close(e);\n" \
+    "                }\n" \
+    "            });\n" \
+    "\n" \
+    "            var many = reader.readMany();\n" \
+    "            if (many && @isPromise(many)) {\n" \
+    "                many = await many;\n" \
+    "            }\n" \
+    "\n" \
+    "            if (many.done) {\n" \
+    "                didClose = true;\n" \
+    "                sink.end();\n" \
+    "                return;\n" \
+    "            }\n" \
+    "\n" \
+    "            sink.start();\n" \
+    "            var wroteCount = many.value.length;\n" \
+    "            for (var i = 0, values = many.value, length = many.value.length; i < length; i++) {\n" \
+    "                sink.write(values[i]);\n" \
+    "            }\n" \
+    "\n" \
+    "            if (wroteCount > 0) {\n" \
+    "                sink.drain();\n" \
+    "            }\n" \
+    "            \n" \
+    "            while (true) {\n" \
+    "                var result = await reader.read();\n" \
+    "                if (result.done) {\n" \
+    "                    didClose = true;\n" \
+    "                    return sink.end();\n" \
+    "                }\n" \
+    "\n" \
+    "                sink.write(result.value);\n" \
+    "            }\n" \
+    "        } catch (e) {\n" \
+    "            globalThis.console.error(e);\n" \
+    "\n" \
+    "        }\n" \
+    "    })();\n" \
     "})\n" \
 ;
 
@@ -823,11 +919,11 @@ const char* const s_readableStreamInternalsHandleDirectStreamErrorRejectCode =
     "})\n" \
 ;
 
-const JSC::ConstructAbility s_readableStreamInternalsOnPullDirectStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
-const JSC::ConstructorKind s_readableStreamInternalsOnPullDirectStreamCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamInternalsOnPullDirectStreamCodeLength = 1701;
-static const JSC::Intrinsic s_readableStreamInternalsOnPullDirectStreamCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_readableStreamInternalsOnPullDirectStreamCode =
+const JSC::ConstructAbility s_readableStreamInternalsOnPullArrayBufferSinkCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
+const JSC::ConstructorKind s_readableStreamInternalsOnPullArrayBufferSinkCodeConstructorKind = JSC::ConstructorKind::None;
+const int s_readableStreamInternalsOnPullArrayBufferSinkCodeLength = 1701;
+static const JSC::Intrinsic s_readableStreamInternalsOnPullArrayBufferSinkCodeIntrinsic = JSC::NoIntrinsic;
+const char* const s_readableStreamInternalsOnPullArrayBufferSinkCode =
     "(function (controller)\n" \
     "{\n" \
     "    \n" \
@@ -1049,7 +1145,7 @@ const char* const s_readableStreamInternalsOnDrainDirectStreamCode =
 
 const JSC::ConstructAbility s_readableStreamInternalsInitializeArrayBufferStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInternalsInitializeArrayBufferStreamCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamInternalsInitializeArrayBufferStreamCodeLength = 930;
+const int s_readableStreamInternalsInitializeArrayBufferStreamCodeLength = 933;
 static const JSC::Intrinsic s_readableStreamInternalsInitializeArrayBufferStreamCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamInternalsInitializeArrayBufferStreamCode =
     "(function (underlyingSource, highWaterMark)\n" \
@@ -1066,7 +1162,7 @@ const char* const s_readableStreamInternalsInitializeArrayBufferStreamCode =
     "\n" \
     "    var controller = {\n" \
     "        @underlyingSource: underlyingSource,\n" \
-    "        @pull: @onPullDirectStream,\n" \
+    "        @pull: @onPullArrayBufferSink,\n" \
     "        @controlledReadableStream: this,\n" \
     "        @sink: sink,\n" \
     "        close: @onCloseDirectStream,\n" \
diff --git a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h
index a17ea08bb..7332fc125 100644
--- a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h
+++ b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h
@@ -147,10 +147,10 @@ extern const char* const s_readableStreamInternalsIsReadableStreamDefaultControl
 extern const int s_readableStreamInternalsIsReadableStreamDefaultControllerCodeLength;
 extern const JSC::ConstructAbility s_readableStreamInternalsIsReadableStreamDefaultControllerCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamInternalsIsReadableStreamDefaultControllerCodeConstructorKind;
-extern const char* const s_readableStreamInternalsAssignDirectStreamCode;
-extern const int s_readableStreamInternalsAssignDirectStreamCodeLength;
-extern const JSC::ConstructAbility s_readableStreamInternalsAssignDirectStreamCodeConstructAbility;
-extern const JSC::ConstructorKind s_readableStreamInternalsAssignDirectStreamCodeConstructorKind;
+extern const char* const s_readableStreamInternalsAssignToStreamCode;
+extern const int s_readableStreamInternalsAssignToStreamCodeLength;
+extern const JSC::ConstructAbility s_readableStreamInternalsAssignToStreamCodeConstructAbility;
+extern const JSC::ConstructorKind s_readableStreamInternalsAssignToStreamCodeConstructorKind;
 extern const char* const s_readableStreamInternalsHandleDirectStreamErrorCode;
 extern const int s_readableStreamInternalsHandleDirectStreamErrorCodeLength;
 extern const JSC::ConstructAbility s_readableStreamInternalsHandleDirectStreamErrorCodeConstructAbility;
@@ -159,10 +159,10 @@ extern const char* const s_readableStreamInternalsHandleDirectStreamErrorRejectC
 extern const int s_readableStreamInternalsHandleDirectStreamErrorRejectCodeLength;
 extern const JSC::ConstructAbility s_readableStreamInternalsHandleDirectStreamErrorRejectCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamInternalsHandleDirectStreamErrorRejectCodeConstructorKind;
-extern const char* const s_readableStreamInternalsOnPullDirectStreamCode;
-extern const int s_readableStreamInternalsOnPullDirectStreamCodeLength;
-extern const JSC::ConstructAbility s_readableStreamInternalsOnPullDirectStreamCodeConstructAbility;
-extern const JSC::ConstructorKind s_readableStreamInternalsOnPullDirectStreamCodeConstructorKind;
+extern const char* const s_readableStreamInternalsOnPullArrayBufferSinkCode;
+extern const int s_readableStreamInternalsOnPullArrayBufferSinkCodeLength;
+extern const JSC::ConstructAbility s_readableStreamInternalsOnPullArrayBufferSinkCodeConstructAbility;
+extern const JSC::ConstructorKind s_readableStreamInternalsOnPullArrayBufferSinkCodeConstructorKind;
 extern const char* const s_readableStreamInternalsNoopDoneFunctionCode;
 extern const int s_readableStreamInternalsNoopDoneFunctionCodeLength;
 extern const JSC::ConstructAbility s_readableStreamInternalsNoopDoneFunctionCodeConstructAbility;
@@ -286,10 +286,10 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
     macro(isReadableStream, readableStreamInternalsIsReadableStream, 1) \
     macro(isReadableStreamDefaultReader, readableStreamInternalsIsReadableStreamDefaultReader, 1) \
     macro(isReadableStreamDefaultController, readableStreamInternalsIsReadableStreamDefaultController, 1) \
-    macro(assignDirectStream, readableStreamInternalsAssignDirectStream, 0) \
+    macro(assignToStream, readableStreamInternalsAssignToStream, 2) \
     macro(handleDirectStreamError, readableStreamInternalsHandleDirectStreamError, 1) \
     macro(handleDirectStreamErrorReject, readableStreamInternalsHandleDirectStreamErrorReject, 1) \
-    macro(onPullDirectStream, readableStreamInternalsOnPullDirectStream, 1) \
+    macro(onPullArrayBufferSink, readableStreamInternalsOnPullArrayBufferSink, 1) \
     macro(noopDoneFunction, readableStreamInternalsNoopDoneFunction, 0) \
     macro(onReadableStreamDirectControllerClosed, readableStreamInternalsOnReadableStreamDirectControllerClosed, 1) \
     macro(onCloseDirectStream, readableStreamInternalsOnCloseDirectStream, 1) \
@@ -340,10 +340,10 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ISREADABLESTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ISREADABLESTREAMDEFAULTREADER 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ISREADABLESTREAMDEFAULTCONTROLLER 1
-#define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ASSIGNDIRECTSTREAM 1
+#define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ASSIGNTOSTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_HANDLEDIRECTSTREAMERROR 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_HANDLEDIRECTSTREAMERRORREJECT 1
-#define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ONPULLDIRECTSTREAM 1
+#define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ONPULLARRAYBUFFERSINK 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_NOOPDONEFUNCTION 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ONREADABLESTREAMDIRECTCONTROLLERCLOSED 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ONCLOSEDIRECTSTREAM 1
@@ -395,10 +395,10 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
     macro(readableStreamInternalsIsReadableStreamCode, isReadableStream, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamCodeLength) \
     macro(readableStreamInternalsIsReadableStreamDefaultReaderCode, isReadableStreamDefaultReader, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDefaultReaderCodeLength) \
     macro(readableStreamInternalsIsReadableStreamDefaultControllerCode, isReadableStreamDefaultController, ASCIILiteral(), s_readableStreamInternalsIsReadableStreamDefaultControllerCodeLength) \
-    macro(readableStreamInternalsAssignDirectStreamCode, assignDirectStream, ASCIILiteral(), s_readableStreamInternalsAssignDirectStreamCodeLength) \
+    macro(readableStreamInternalsAssignToStreamCode, assignToStream, ASCIILiteral(), s_readableStreamInternalsAssignToStreamCodeLength) \
     macro(readableStreamInternalsHandleDirectStreamErrorCode, handleDirectStreamError, ASCIILiteral(), s_readableStreamInternalsHandleDirectStreamErrorCodeLength) \
     macro(readableStreamInternalsHandleDirectStreamErrorRejectCode, handleDirectStreamErrorReject, ASCIILiteral(), s_readableStreamInternalsHandleDirectStreamErrorRejectCodeLength) \
-    macro(readableStreamInternalsOnPullDirectStreamCode, onPullDirectStream, ASCIILiteral(), s_readableStreamInternalsOnPullDirectStreamCodeLength) \
+    macro(readableStreamInternalsOnPullArrayBufferSinkCode, onPullArrayBufferSink, ASCIILiteral(), s_readableStreamInternalsOnPullArrayBufferSinkCodeLength) \
     macro(readableStreamInternalsNoopDoneFunctionCode, noopDoneFunction, ASCIILiteral(), s_readableStreamInternalsNoopDoneFunctionCodeLength) \
     macro(readableStreamInternalsOnReadableStreamDirectControllerClosedCode, onReadableStreamDirectControllerClosed, ASCIILiteral(), s_readableStreamInternalsOnReadableStreamDirectControllerClosedCodeLength) \
     macro(readableStreamInternalsOnCloseDirectStreamCode, onCloseDirectStream, ASCIILiteral(), s_readableStreamInternalsOnCloseDirectStreamCodeLength) \
@@ -426,7 +426,7 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
 
 #define WEBCORE_FOREACH_READABLESTREAMINTERNALS_BUILTIN_FUNCTION_NAME(macro) \
     macro(acquireReadableStreamDefaultReader) \
-    macro(assignDirectStream) \
+    macro(assignToStream) \
     macro(createReadableStreamController) \
     macro(handleDirectStreamError) \
     macro(handleDirectStreamErrorReject) \
@@ -440,7 +440,7 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
     macro(noopDoneFunction) \
     macro(onCloseDirectStream) \
     macro(onDrainDirectStream) \
-    macro(onPullDirectStream) \
+    macro(onPullArrayBufferSink) \
     macro(onReadableStreamDirectControllerClosed) \
     macro(pipeToClosingMustBePropagatedBackward) \
     macro(pipeToClosingMustBePropagatedForward) \
diff --git a/src/bun.js/builtins/cpp/WebCoreJSBuiltinInternals.h b/src/bun.js/builtins/cpp/WebCoreJSBuiltinInternals.h
index cefa5fd8c..57b4f2936 100644
--- a/src/bun.js/builtins/cpp/WebCoreJSBuiltinInternals.h
+++ b/src/bun.js/builtins/cpp/WebCoreJSBuiltinInternals.h
@@ -83,6 +83,17 @@ namespace Zig { class GlobalObject; }
 namespace Zig { class GlobalObject; }
 namespace Zig { class GlobalObject; }
 namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
+namespace Zig { class GlobalObject; }
 /*
  * Copyright (c) 2015 Igalia
  * Copyright (c) 2015 Igalia S.L.
diff --git a/src/bun.js/builtins/js/ReadableStream.js b/src/bun.js/builtins/js/ReadableStream.js
index db7cf85a8..f3c11728e 100644
--- a/src/bun.js/builtins/js/ReadableStream.js
+++ b/src/bun.js/builtins/js/ReadableStream.js
@@ -62,14 +62,17 @@ function initializeReadableStream(underlyingSource, strategy)
     if (@getByIdDirectPrivate(underlyingSource, "pull") !== @undefined && !isLazy) {
         const size = @getByIdDirectPrivate(strategy, "size");
         const highWaterMark = @getByIdDirectPrivate(strategy, "highWaterMark");
+        @putByIdDirectPrivate(this, "underlyingSource", @undefined);
         @setupReadableStreamDefaultController(this, underlyingSource, size, highWaterMark !== @undefined ? highWaterMark : 1, @getByIdDirectPrivate(underlyingSource, "start"), @getByIdDirectPrivate(underlyingSource, "pull"), @getByIdDirectPrivate(underlyingSource, "cancel"));
         
         return this;
     }
     if (isDirect) {
+        @putByIdDirectPrivate(this, "underlyingSource", underlyingSource);
         @putByIdDirectPrivate(this, "start", () => @createReadableStreamController(this, underlyingSource, strategy));
     } else if (isLazy) {
         const autoAllocateChunkSize = underlyingSource.autoAllocateChunkSize;
+        @putByIdDirectPrivate(this, "underlyingSource", @undefined);
 
         
         @putByIdDirectPrivate(this, "start", () => {
@@ -79,6 +82,7 @@ function initializeReadableStream(underlyingSource, strategy)
             }
         });
     } else {
+        @putByIdDirectPrivate(this, "underlyingSource", @undefined);
         @putByIdDirectPrivate(this, "start", @undefined);
         @createReadableStreamController(this, underlyingSource, strategy);
     }
diff --git a/src/bun.js/builtins/js/ReadableStreamDefaultReader.js b/src/bun.js/builtins/js/ReadableStreamDefaultReader.js
index 774c7161e..e3e39b2da 100644
--- a/src/bun.js/builtins/js/ReadableStreamDefaultReader.js
+++ b/src/bun.js/builtins/js/ReadableStreamDefaultReader.js
@@ -87,6 +87,11 @@ function readMany()
                     value[i] = new @Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
                 }
             }
+        } else {
+            values[0] = values[0].value;
+            for (var i = 1; i < values.length; i++) {
+                values[i] = values[i].value;
+            }
         }
         
         @resetQueue(@getByIdDirectPrivate(controller, "queue"));
@@ -117,6 +122,10 @@ function readMany()
                     value[i] = new @Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
                 }
             }
+        } else {
+            for (var i = 1; i < value.length; i++) {
+                value[i] = value[i].value;
+            }
         }
         
         var size = queue.size;
diff --git a/src/bun.js/builtins/js/ReadableStreamInternals.js b/src/bun.js/builtins/js/ReadableStreamInternals.js
index 3e6590f31..f988aa091 100644
--- a/src/bun.js/builtins/js/ReadableStreamInternals.js
+++ b/src/bun.js/builtins/js/ReadableStreamInternals.js
@@ -601,10 +601,106 @@ function isReadableStreamDefaultController(controller)
 
 
 @globalPrivate
-function assignDirectStream() {
+function assignToStream(stream, sink) {
     "use strict";
 
-    var stream = this;
+    // The stream is either a direct stream or a "default" JS stream
+    const underlyingSource = @getByIdDirectPrivate(stream, "underlyingSource");
+
+    // we know it's a direct stream when @underlyingSource is set
+    if (underlyingSource) {
+        var originalClose = underlyingSource.close;
+        var reader;
+        var close = (reason) => {
+            originalClose && originalClose(reason);
+            try {
+                reader && reader.releaseLock();
+            } catch (e) {}
+            @readableStreamClose(stream, reason);
+            
+        }
+        var pull = underlyingSource.pull;
+       
+        @putByIdDirectPrivate(stream, "readableStreamController", sink);
+        @putByIdDirectPrivate(stream, "start", @undefined);
+        @putByIdDirectPrivate(stream, "underlyingSource", @undefined);
+
+        @startDirectStream.@call(sink, stream, pull, close);
+
+        if (!pull) {
+            close();
+            return;
+        }
+
+        if (!@isCallable(pull)) {
+            close();
+            @throwTypeError("pull is not a function");
+            return;
+        }
+
+        // lock the stream, relying on close() or end() to eventaully close it
+        reader = stream.getReader();
+
+        pull(sink);
+        return;
+    }
+
+   
+    return (async function() {
+        "use strict";
+
+        var didClose = false;
+
+
+        try {
+            var reader = stream.getReader();
+            reader.closed.then(() => {
+                if (!didClose && sink) {
+                    didClose = true;
+                    sink.end();
+                }
+            }, (e) => {
+                if (!didClose && sink) {
+                    didClose = true;
+                    sink.close(e);
+                }
+            });
+
+            var many = reader.readMany();
+            if (many && @isPromise(many)) {
+                many = await many;
+            }
+
+            if (many.done) {
+                didClose = true;
+                sink.end();
+                return;
+            }
+
+            sink.start();
+            var wroteCount = many.value.length;
+            for (var i = 0, values = many.value, length = many.value.length; i < length; i++) {
+                sink.write(values[i]);
+            }
+
+            if (wroteCount > 0) {
+                sink.drain();
+            }
+            
+            while (true) {
+                var result = await reader.read();
+                if (result.done) {
+                    didClose = true;
+                    return sink.end();
+                }
+
+                sink.write(result.value);
+            }
+        } catch (e) {
+            globalThis.console.error(e);
+
+        }
+    })();
 }
 
 
@@ -645,7 +741,7 @@ function handleDirectStreamErrorReject(e) {
     return @Promise.@reject(e);
 }
 
-function onPullDirectStream(controller)
+function onPullArrayBufferSink(controller)
 {
     
     "use strict";
@@ -853,7 +949,7 @@ function initializeArrayBufferStream(underlyingSource, highWaterMark)
 
     var controller = {
         @underlyingSource: underlyingSource,
-        @pull: @onPullDirectStream,
+        @pull: @onPullArrayBufferSink,
         @controlledReadableStream: this,
         @sink: sink,
         close: @onCloseDirectStream,
diff --git a/src/bun.js/generate-jssink.js b/src/bun.js/generate-jssink.js
index 1d20be64f..5ff5827ba 100644
--- a/src/bun.js/generate-jssink.js
+++ b/src/bun.js/generate-jssink.js
@@ -1,4 +1,4 @@
-const classes = ["ArrayBufferSink"];
+const classes = ["ArrayBufferSink", "HTTPResponseSink", "HTTPSResponseSink"];
 const SINK_COUNT = 5;
 
 function names(name) {
@@ -157,8 +157,6 @@ function header() {
 
 JSC_DECLARE_CUSTOM_GETTER(function${name}__getter);
 
-
-
         `;
   }
 
@@ -305,7 +303,7 @@ JSC_DEFINE_HOST_FUNCTION(functionStartDirectStream, (JSC::JSGlobalObject * lexic
       isFirst ? "" : "else"
     } if (WebCore::${controller}* ${name}Controller = JSC::jsDynamicCast<WebCore::${controller}*>(callFrame->thisValue())) {
         if (${name}Controller->wrapped() == nullptr) {
-            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Controller is already closed"_s));
+            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
             return JSC::JSValue::encode(JSC::jsUndefined());
         }
 
@@ -360,7 +358,6 @@ JSC_DEFINE_HOST_FUNCTION(${controller}__close, (JSC::JSGlobalObject * lexicalGlo
 
     void *ptr = controller->wrapped();
     if (ptr == nullptr) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Controller is already closed"_s));
         return JSC::JSValue::encode(JSC::jsUndefined());
     }
 
@@ -369,6 +366,29 @@ JSC_DEFINE_HOST_FUNCTION(${controller}__close, (JSC::JSGlobalObject * lexicalGlo
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
+JSC_DECLARE_HOST_FUNCTION(${controller}__end);
+JSC_DEFINE_HOST_FUNCTION(${controller}__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
+{
+    
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    WebCore::${controller}* controller = JSC::jsDynamicCast<WebCore::${controller}*>(callFrame->thisValue());
+    if (!controller) {
+        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected ${controller}"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void *ptr = controller->wrapped();
+    if (ptr == nullptr) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    controller->detach();
+    return ${name}__endWithSink(ptr, lexicalGlobalObject);
+}
+
+
 JSC_DECLARE_HOST_FUNCTION(${name}__doClose);
 JSC_DEFINE_HOST_FUNCTION(${name}__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
 {
@@ -384,7 +404,6 @@ JSC_DEFINE_HOST_FUNCTION(${name}__doClose, (JSC::JSGlobalObject * lexicalGlobalO
 
     void *ptr = sink->wrapped();
     if (ptr == nullptr) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Controller is already closed"_s));
         return JSC::JSValue::encode(JSC::jsUndefined());
     }
 
@@ -409,7 +428,7 @@ static const HashTableValue ${controllerPrototypeName}TableValues[]
       = {
             { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${controller}__close), (intptr_t)(0) } },
             { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${name}__drain), (intptr_t)(1) } },
-            { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${name}__end), (intptr_t)(0) } },
+            { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${controller}__end), (intptr_t)(0) } },
             { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${name}__start), (intptr_t)(1) } },
             { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${name}__write), (intptr_t)(1) } },
         };
@@ -724,43 +743,89 @@ extern "C" void* ${name}__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue
     return nullptr;
 }
 
-extern "C" JSC__JSValue ${name}__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, int32_t *bunNativeTag, void** bunNativePtr)
+extern "C" void ${name}__detachPtr(JSC__JSValue JSValue0)
+{
+    if (auto* sink = JSC::jsDynamicCast<WebCore::JS${name}*>(JSC::JSValue::decode(JSValue0))) {
+        sink->detach();
+        return;
+    }
+        
+
+    if (auto* controller = JSC::jsDynamicCast<WebCore::${controller}*>(JSC::JSValue::decode(JSValue0))) {
+        controller->detach();
+        return;
+    }
+}
+
+extern "C" JSC__JSValue ${name}__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void **controllerValue)
 {
     auto& vm = arg0->vm();
     Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
     auto clientData = WebCore::clientData(vm);
     JSC::JSObject *readableStream = JSC::JSValue::decode(stream).getObject();
-
-    if (JSC::JSValue tag = readableStream->get(globalObject, clientData->builtinNames().bunNativeTypePrivateName())) {
-        if (tag.isInt32()) {
-            int32_t tagNumber = tag.toInt32(arg0);
-            if (tagNumber > 0 && tagNumber < 5) {
-                *bunNativeTag = tagNumber;
-                *bunNativePtr = reinterpret_cast<void*>(bitwise_cast<uintptr_t>(readableStream->get(globalObject, clientData->builtinNames().bunNativePtrPrivateName()).asNumber()));
-                return JSC::JSValue::encode(JSC::jsNull());
-            }
-        }
-    }
+    auto scope = DECLARE_CATCH_SCOPE(vm);
 
     JSC::JSValue prototype = globalObject->${controllerPrototypeName}();
     JSC::Structure* structure = WebCore::${controller}::createStructure(vm, globalObject, prototype);
     WebCore::${controller} *controller = WebCore::${controller}::create(vm, globalObject, structure, sinkPtr);
-
-    JSC::JSObject *function = globalObject->getDirect(vm, clientData->builtinNames().assignDirectStreamPrivateName()).getObject();
+    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
+    JSC::JSObject *function = globalObject->getDirect(vm, clientData->builtinNames().assignToStreamPrivateName()).getObject();
     auto callData = JSC::getCallData(function);
     JSC::MarkedArgumentBuffer arguments;
     arguments.append(JSC::JSValue::decode(stream));
     arguments.append(controller);
 
     auto result = JSC::call(arg0, function, callData, JSC::jsUndefined(), arguments);
+    if (scope.exception())
+        return JSC::JSValue::encode(scope.exception());
+
     return JSC::JSValue::encode(result);
 }
 
+extern "C" void ${name}__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
+{
+    WebCore::${controller}* controller = JSC::jsCast<WebCore::${controller}*>(JSC::JSValue::decode(controllerValue).getObject());
+
+    JSC::JSFunction *function = controller->m_onPull.get();
+    if (function == nullptr)
+        return;
+    JSC::JSGlobalObject *globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(amt));
+    arguments.append(JSC::JSValue::decode(offset));
+
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
+
+extern "C" void ${name}__onStart(JSC__JSValue controllerValue)
+{
+
+}
+
+extern "C" void ${name}__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
+{
+    WebCore::${controller}* controller = JSC::jsCast<WebCore::${controller}*>(JSC::JSValue::decode(controllerValue).getObject());
 
+    JSC::JSFunction *function = controller->m_onClose.get();
+    if (function == nullptr)
+        return;
+    // only call close once
+    controller->m_onClose.clear();
+    JSC::JSGlobalObject *globalObject = controller->globalObject();
+
+    auto callData = JSC::getCallData(function);
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(controller);
+    arguments.append(JSC::JSValue::decode(reason));
+    JSC::call(globalObject, function, callData, JSC::jsUndefined(), arguments);
+}
 
 `;
-    return templ;
   }
+  return templ;
 }
 
 await Bun.write(import.meta.dir + "/bindings/JSSink.h", header());
diff --git a/src/bun.js/javascript.zig b/src/bun.js/javascript.zig
index b9b01cc1e..90d29bf6f 100644
--- a/src/bun.js/javascript.zig
+++ b/src/bun.js/javascript.zig
@@ -1182,7 +1182,7 @@ pub const VirtualMachine = struct {
             return;
         } else if (HardcodedModule.Map.get(specifier)) |result| {
             ret.result = null;
-            ret.path = std.mem.span(@tagName(result));
+            ret.path = @as(string, @tagName(result));
             return;
         }
 
diff --git a/src/bun.js/test/jest.zig b/src/bun.js/test/jest.zig
index 2128bc131..31141472a 100644
--- a/src/bun.js/test/jest.zig
+++ b/src/bun.js/test/jest.zig
@@ -788,7 +788,7 @@ pub const DescribeScope = struct {
                 }
 
                 JSC.JSValue.c(arguments[0]).protect();
-                const name = comptime std.mem.span(@tagName(this_hook));
+                const name = comptime @as(string, @tagName(this_hook));
                 @field(this, name).append(getAllocator(ctx), JSC.JSValue.c(arguments[0])) catch unreachable;
                 return JSC.JSValue.jsBoolean(true).asObjectRef();
             }
@@ -819,7 +819,7 @@ pub const DescribeScope = struct {
     );
 
     pub fn execCallback(this: *DescribeScope, ctx: js.JSContextRef, comptime hook: LifecycleHook) JSValue {
-        const name = comptime std.mem.span(@tagName(hook));
+        const name = comptime @as(string, @tagName(hook));
         var hooks: []JSC.JSValue = @field(this, name).items;
         for (hooks) |cb, i| {
             if (cb.isEmpty()) continue;
diff --git a/src/bun.js/webcore/response.zig b/src/bun.js/webcore/response.zig
index 017edb805..4d2f92e59 100644
--- a/src/bun.js/webcore/response.zig
+++ b/src/bun.js/webcore/response.zig
@@ -1103,6 +1103,10 @@ pub const Blob = struct {
     pub const SizeType = u52;
     pub const max_size = std.math.maxInt(SizeType);
 
+    pub fn isDetached(this: *const Blob) bool {
+        return this.store == null;
+    }
+
     const CopyFilePromiseHandler = struct {
         promise: *JSPromise,
         globalThis: *JSGlobalObject,
@@ -3820,7 +3824,7 @@ pub const Body = struct {
         pub fn setPromise(value: *PendingValue, globalThis: *JSC.JSGlobalObject, action: Action) JSValue {
             value.action = action;
 
-            if (value.readable) |*readable| {
+            if (value.readable) |readable| {
                 // switch (readable.ptr) {
                 //     .JavaScript
                 // }
diff --git a/src/bun.js/webcore/streams.zig b/src/bun.js/webcore/streams.zig
index f07cc7c26..5d568e459 100644
--- a/src/bun.js/webcore/streams.zig
+++ b/src/bun.js/webcore/streams.zig
@@ -55,36 +55,67 @@ pub const ReadableStream = struct {
         this.value.unprotect();
     }
 
+    pub fn cancel(this: *const ReadableStream, globalThis: *JSGlobalObject) void {
+        JSC.markBinding();
+        ReadableStream__cancel(this.value, globalThis);
+    }
+
+    pub fn abort(this: *const ReadableStream, globalThis: *JSGlobalObject) void {
+        JSC.markBinding();
+        ReadableStream__abort(this.value, globalThis);
+    }
+
+    pub fn detach(this: *const ReadableStream, globalThis: *JSGlobalObject) void {
+        JSC.markBinding();
+        ReadableStream__detach(this.value, globalThis);
+    }
+
     pub const Tag = enum(i32) {
         Invalid = -1,
 
+        /// ReadableStreamDefaultController or ReadableByteStreamController
         JavaScript = 0,
+
+        /// ReadableByteStreamController
+        /// but with a BlobLoader
+        /// we can skip the BlobLoader and just use the underlying Blob
         Blob = 1,
+
+        /// ReadableByteStreamController
+        /// but with a FileLoader
+        /// we can skip the FileLoader and just use the underlying File
         File = 2,
-        HTTPRequest = 3,
-        HTTPSRequest = 4,
-        HTTPResponse = 5,
-        HTTPSResponse = 6,
+
+        /// This is a direct readable stream
+        /// That means we can turn it into whatever we want
+        Direct = 3,
     };
     pub const Source = union(Tag) {
         Invalid: void,
+        /// ReadableStreamDefaultController or ReadableByteStreamController
         JavaScript: void,
+        /// ReadableByteStreamController
+        /// but with a BlobLoader
+        /// we can skip the BlobLoader and just use the underlying Blob
         Blob: *ByteBlobLoader,
+
+        /// ReadableByteStreamController
+        /// but with a FileLoader
+        /// we can skip the FileLoader and just use the underlying File
         File: *FileBlobLoader,
-        // HTTPRequest: *HTTPRequest,
-        HTTPRequest: void,
-        // HTTPSRequest: *HTTPSRequest,
-        HTTPSRequest: void,
-        // HTTPRequest: *HTTPRequest,
-        HTTPResponse: void,
-        // HTTPSRequest: *HTTPSRequest,
-        HTTPSResponse: void,
+
+        /// This is a direct readable stream
+        /// That means we can turn it into whatever we want
+        Direct: void,
     };
 
     extern fn ReadableStreamTag__tagged(globalObject: *JSGlobalObject, possibleReadableStream: JSValue, ptr: *JSValue) Tag;
     extern fn ReadableStream__isDisturbed(possibleReadableStream: JSValue, globalObject: *JSGlobalObject) bool;
     extern fn ReadableStream__isLocked(possibleReadableStream: JSValue, globalObject: *JSGlobalObject) bool;
     extern fn ReadableStream__empty(*JSGlobalObject) JSC.JSValue;
+    extern fn ReadableStream__cancel(stream: JSValue, *JSGlobalObject) void;
+    extern fn ReadableStream__abort(stream: JSValue, *JSGlobalObject) void;
+    extern fn ReadableStream__detach(stream: JSValue, *JSGlobalObject) void;
     extern fn ReadableStream__fromBlob(
         *JSGlobalObject,
         store: *anyopaque,
@@ -498,14 +529,22 @@ pub const StreamResult = union(Tag) {
 };
 
 pub const Signal = struct {
-    ptr: *anyopaque = @intToPtr(*anyopaque, 0xaaaaaaaa),
+    ptr: *anyopaque = dead,
     vtable: VTable = VTable.Dead,
 
+    pub const dead = @intToPtr(*anyopaque, 0xaaaaaaaa);
+
+    pub fn clear(this: *Signal) void {
+        this.ptr = dead;
+    }
+
     pub fn isDead(this: Signal) bool {
-        return this.ptr == @intToPtr(*anyopaque, 0xaaaaaaaa);
+        return this.ptr == dead;
     }
 
-    pub fn initWithType(comptime Type: type, handler: *Type) Sink {
+    pub fn initWithType(comptime Type: type, handler: *Type) Signal {
+        // this is nullable when used as a JSValue
+        @setRuntimeSafety(false);
         return .{
             .ptr = handler,
             .vtable = VTable.wrap(Type),
@@ -963,6 +1002,45 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
         pub const shim = JSC.Shimmer("", std.mem.span(name_), @This());
         pub const name = std.fmt.comptimePrint("{s}", .{std.mem.span(name_)});
 
+        // This attaches it to JS
+        pub const SinkSignal = struct {
+            cpp: JSValue,
+
+            pub fn init(cpp: JSValue) Signal {
+                // this one can be null
+                @setRuntimeSafety(false);
+                return Signal.initWithType(SinkSignal, @intToPtr(*SinkSignal, @bitCast(usize, @enumToInt(cpp))));
+            }
+
+            pub fn close(this: *@This(), _: ?JSC.Node.Syscall.Error) void {
+                onClose(@bitCast(SinkSignal, @ptrToInt(this)).cpp, JSValue.jsUndefined());
+            }
+
+            pub fn ready(this: *@This(), _: ?Blob.SizeType, _: ?Blob.SizeType) void {
+                onReady(@bitCast(SinkSignal, @ptrToInt(this)).cpp, JSValue.jsUndefined(), JSValue.jsUndefined());
+            }
+
+            pub fn start(_: *@This()) void {}
+        };
+
+        pub fn onClose(ptr: JSValue, reason: JSValue) callconv(.C) void {
+            JSC.markBinding();
+
+            return shim.cppFn("onClose", .{ ptr, reason });
+        }
+
+        pub fn onReady(ptr: JSValue, amount: JSValue, offset: JSValue) callconv(.C) void {
+            JSC.markBinding();
+
+            return shim.cppFn("onReady", .{ ptr, amount, offset });
+        }
+
+        pub fn onStart(ptr: JSValue, globalThis: *JSGlobalObject) callconv(.C) void {
+            JSC.markBinding();
+
+            return shim.cppFn("onStart", .{ ptr, globalThis });
+        }
+
         pub fn createObject(globalThis: *JSGlobalObject, object: *anyopaque) callconv(.C) JSValue {
             JSC.markBinding();
 
@@ -977,6 +1055,19 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
 
         pub fn construct(globalThis: *JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSValue {
             JSC.markBinding();
+
+            if (comptime !@hasDecl(SinkType, "construct")) {
+                const Static = struct {
+                    pub const message = std.fmt.comptimePrint("{s} is not constructable", .{SinkType.name});
+                };
+                const err = JSC.SystemError{
+                    .message = ZigString.init(Static.message),
+                    .code = ZigString.init(@as(string, @tagName(JSC.Node.ErrorCode.ERR_ILLEGAL_CONSTRUCTOR))),
+                };
+                globalThis.vm().throwError(globalThis, err.toErrorInstance(globalThis));
+                return JSC.JSValue.jsUndefined();
+            }
+
             var allocator = globalThis.bunVM().allocator;
             var this = allocator.create(ThisSink) catch {
                 globalThis.vm().throwError(globalThis, JSC.Node.Syscall.Error.oom.toJSC(
@@ -994,6 +1085,21 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             this.sink.finalize();
         }
 
+        pub fn detach(this: *ThisSink) void {
+            if (comptime !@hasField(SinkType, "signal"))
+                return;
+
+            var ptr = this.sink.signal.ptr;
+            if (this.sink.signal.isDead())
+                return;
+            this.sink.signal.clear();
+            detachPtr(@intToEnum(JSValue, @bitCast(JSC.JSValueReprInt, @ptrToInt(ptr))));
+        }
+
+        pub fn detachPtr(ptr: JSValue) callconv(.C) void {
+            shim.cppFn("detachPtr", .{ptr});
+        }
+
         pub fn write(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSValue {
             JSC.markBinding();
             var this = @ptrCast(*ThisSink, @alignCast(std.meta.alignment(ThisSink), fromJS(globalThis, callframe.this()) orelse {
@@ -1010,6 +1116,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             }
 
             const args = callframe.arguments();
+
             if (args.len == 0 or args[0].isEmptyOrUndefinedOrNull() or args[0].isNumber()) {
                 const err = JSC.toTypeError(
                     if (args.len == 0) JSC.Node.ErrorCode.ERR_MISSING_ARGS else JSC.Node.ErrorCode.ERR_INVALID_ARG_TYPE,
@@ -1182,6 +1289,25 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             return this.sink.endFromJS(globalThis).toJS(globalThis);
         }
 
+        pub fn endWithSink(ptr: *anyopaque, globalThis: *JSGlobalObject) callconv(.C) JSValue {
+            JSC.markBinding();
+
+            var this = @ptrCast(*ThisSink, @alignCast(std.meta.alignment(ThisSink), ptr));
+
+            if (comptime @hasDecl(SinkType, "getPendingError")) {
+                if (this.sink.getPendingError()) |err| {
+                    globalThis.vm().throwError(globalThis, err);
+                    return JSC.JSValue.jsUndefined();
+                }
+            }
+
+            return this.sink.endFromJS(globalThis).toJS(globalThis);
+        }
+
+        pub fn assignToStream(globalThis: *JSGlobalObject, stream: JSValue, ptr: *anyopaque, jsvalue_ptr: **anyopaque) JSValue {
+            return shim.cppFn("assignToStream", .{ globalThis, stream, ptr, jsvalue_ptr });
+        }
+
         pub const Export = shim.exportFunctions(.{
             .@"finalize" = finalize,
             .@"write" = write,
@@ -1190,6 +1316,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             .@"start" = start,
             .@"end" = end,
             .@"construct" = construct,
+            .@"endWithSink" = endWithSink,
         });
 
         comptime {
@@ -1201,10 +1328,11 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
                 @export(start, .{ .name = Export[4].symbol_name });
                 @export(end, .{ .name = Export[5].symbol_name });
                 @export(construct, .{ .name = Export[6].symbol_name });
+                @export(endWithSink, .{ .name = Export[7].symbol_name });
             }
         }
 
-        pub const Extern = [_][]const u8{ "createObject", "fromJS" };
+        pub const Extern = [_][]const u8{ "createObject", "fromJS", "assignToStream", "onReady", "onClose", "detachPtr" };
     };
 }
 
@@ -1312,91 +1440,401 @@ pub fn HTTPServerWritable(comptime ssl: bool) type {
     return struct {
         pub const UWSResponse = uws.NewApp(ssl).Response;
         res: *UWSResponse,
-        pending_chunk: []const u8 = "",
+        buffer: bun.ByteList,
+        offset: Blob.SizeType = 0,
+
         is_listening_for_abort: bool = false,
         wrote: Blob.SizeType = 0,
         callback: anyframe->JSC.Maybe(Blob.SizeType) = undefined,
-        writable: Writable,
+        has_callback: bool = false,
+
+        allocator: std.mem.Allocator,
+        done: bool = false,
+        signal: Signal = .{},
+        pending_drain: ?*JSC.JSPromise = null,
+        globalThis: *JSGlobalObject = undefined,
+
+        requested_end: bool = false,
+
+        has_backpressure: bool = false,
+        end_len: usize = 0,
+        aborted: bool = false,
+
+        pub fn connect(this: *@This(), signal: Signal) void {
+            this.signal = signal;
+        }
+
+        fn handleWrote(this: *@This(), amount1: usize) void {
+            const amount = @truncate(Blob.SizeType, amount1);
+            this.offset += amount;
+            this.wrote += amount;
+            this.buffer.len -|= @truncate(u32, amount);
+
+            if (this.offset >= this.buffer.len) {
+                this.offset = 0;
+                this.buffer.len = 0;
+            }
+        }
+
+        fn hasBackpressure(this: *const @This()) bool {
+            std.debug.assert(!this.has_backpressure or this.buffer.len > 0);
+            return this.has_backpressure;
+        }
+
+        fn send(this: *@This(), buf: []const u8) bool {
+            std.debug.assert(!this.done);
+            const success = if (!this.requested_end) this.res.write(buf) else this.res.tryEnd(buf, this.end_len);
+            this.has_backpressure = !success;
+            return success;
+        }
+
+        fn readableSlice(this: *@This()) []const u8 {
+            return this.buffer.ptr[this.offset..this.buffer.cap];
+        }
 
         pub fn onWritable(this: *@This(), available: c_ulong, _: *UWSResponse) callconv(.C) bool {
-            const to_write = @minimum(@truncate(Blob.SizeType, available), @truncate(Blob.SizeType, this.pending_chunk.len));
-            if (!this.res.write(this.pending_chunk[0..to_write])) {
+            if (this.done) {
+                this.res.end("", false);
+                return false;
+            }
+
+            // do not write more than available
+            // if we do, it will cause this to be delayed until the next call, each time
+            const to_write = @minimum(@truncate(Blob.SizeType, available), @as(Blob.SizeType, this.buffer.len));
+
+            // figure out how much data exactly to write
+            const readable = this.readableSlice()[0..to_write];
+            if (!this.send(readable)) {
+                // if we were unable to send it, retry
+                this.res.onWritable(*@This(), onWritable, this);
                 return true;
             }
 
-            this.pending_chunk = this.pending_chunk[to_write..];
-            this.wrote += to_write;
-            if (this.pending_chunk.len > 0) {
+            this.handleWrote(@truncate(Blob.SizeType, readable.len));
+            const initial_wrote = this.wrote;
+
+            if (this.buffer.len > 0 and !this.done) {
                 this.res.onWritable(*@This(), onWritable, this);
                 return true;
             }
 
-            var callback = this.callback;
-            this.callback = undefined;
-            // TODO: clarify what the boolean means
-            resume callback;
-            bun.default_allocator.destroy(callback.*);
+            // flush the javascript promise from calling .drain()
+            if (this.pending_drain) |prom| {
+                this.pending_drain = null;
+                prom.asValue(this.globalThis).unprotect();
+                prom.resolve(this.globalThis, JSC.jsNumber(readable.len));
+            }
+
+            if (this.has_callback) {
+                this.has_callback = false;
+
+                var callback = this.callback;
+                this.callback = undefined;
+                // TODO: clarify what the boolean means
+                resume callback;
+            }
+
+            // pending_drain or callback could have caused another send()
+            // so we check again if we should report readiness
+            if (!this.done and !this.requested_end and !this.hasBackpressure()) {
+                const pending = @truncate(Blob.SizeType, available) - to_write;
+                const written_after_drain = this.wrote - initial_wrote;
+                const to_report = pending - @minimum(written_after_drain, pending);
+
+                if ((written_after_drain == initial_wrote and pending == 0) or to_report > 0) {
+                    this.signal.ready(to_report, null);
+                }
+            }
+
             return false;
         }
 
-        pub fn onStart(this: *@This()) void {
+        pub fn start(this: *@This(), _: StreamStart) JSC.Node.Maybe(void) {
             if (this.res.hasResponded()) {
-                this.writable.didClose();
+                this.done = true;
+                this.signal.close(null);
+                return .{ .result = {} };
             }
+
+            this.done = false;
+            this.signal.start();
+            return .{ .result = {} };
         }
-        pub fn onWrite(this: *@This(), bytes: []const u8) JSC.Maybe(Blob.SizeType) {
-            if (this.writable.aborted) {
-                return .{ .result = 0 };
+
+        pub fn drainFromJS(this: *@This(), globalThis: *JSGlobalObject) JSC.Node.Maybe(JSValue) {
+            if (this.buffer.len == 0 or this.done) {
+                return .{ .result = JSValue.jsNumberFromInt32(0) };
             }
 
-            if (this.pending_chunk.len > 0) {
-                return JSC.Maybe(Blob.SizeType).retry;
+            if (this.pending_drain) |prom| {
+                return .{ .result = prom.asValue(globalThis) };
             }
 
-            if (this.res.write(bytes)) {
-                return .{ .result = @truncate(Blob.SizeType, bytes.len) };
+            this.pending_drain = JSC.JSPromise.create(globalThis);
+            this.globalThis = globalThis;
+            var promise_value = this.pending_drain.?.asValue(globalThis);
+            promise_value.protect();
+
+            return .{ .result = promise_value };
+        }
+
+        pub fn drain(this: *@This()) JSC.Node.Maybe(void) {
+            if (this.buffer.len == 0 or this.done) {
+                return .{ .result = {} };
             }
 
-            this.pending_chunk = bytes;
-            this.writable.pending_err = null;
-            suspend {
-                if (!this.is_listening_for_abort) {
-                    this.is_listening_for_abort = true;
-                    this.res.onAborted(*@This(), onAborted);
+            if (this.res.hasResponded()) {
+                this.done = true;
+                this.signal.close(null);
+            }
+
+            return .{ .result = {} };
+        }
+
+        pub fn write(this: *@This(), data: StreamResult) StreamResult.Writable {
+            if (this.done or this.requested_end) {
+                return .{ .owned = 0 };
+            }
+
+            const bytes = data.slice();
+            if (!this.hasBackpressure()) {
+                if (this.buffer.len == 0) {
+                    // fast path:
+                    // - large-ish chunk
+                    // - no backpressure
+                    if (this.send(bytes)) {
+                        this.handleWrote(bytes.len);
+                        return .{ .owned = @truncate(Blob.SizeType, bytes.len) };
+                    }
+
+                    _ = this.buffer.write(this.allocator, bytes) catch {
+                        return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                    };
+                } else {
+                    // kinda fast path:
+                    // - combined chunk is large enough to flush automatically
+                    // - no backpressure
+                    _ = this.buffer.write(this.allocator, bytes) catch {
+                        return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                    };
+                    const readable = this.readableSlice();
+                    if (this.send(readable)) {
+                        this.handleWrote(readable.len);
+                        return .{ .owned = @truncate(Blob.SizeType, readable.len) };
+                    }
                 }
 
                 this.res.onWritable(*@This(), onWritable, this);
-                var frame = bun.default_allocator.create(@TypeOf(@Frame(onWrite))) catch unreachable;
-                this.callback = frame;
-                frame.* = @frame().*;
-            }
-            const wrote = this.wrote;
-            this.wrote = 0;
-            if (this.writable.pending_err) |err| {
-                this.writable.pending_err = null;
-                return .{ .err = err };
+            } else {
+                _ = this.buffer.write(this.allocator, bytes) catch {
+                    return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                };
+            }
+
+            return .{ .owned = @truncate(Blob.SizeType, bytes.len) };
+        }
+        pub const writeBytes = write;
+        pub fn writeLatin1(this: *@This(), data: StreamResult) StreamResult.Writable {
+            if (this.done or this.requested_end) {
+                return .{ .owned = 0 };
+            }
+
+            if (this.res.hasResponded()) {
+                this.signal.close(null);
+                this.done = true;
+                return .{ .done = {} };
+            }
+
+            const bytes = data.slice();
+            if (!this.hasBackpressure()) {
+                if (this.buffer.len == 0 and strings.isAllASCII(bytes)) {
+                    // fast path:
+                    // - large-ish chunk
+                    // - no backpressure
+                    if (this.send(bytes)) {
+                        this.handleWrote(bytes.len);
+                        return .{ .owned = @truncate(Blob.SizeType, bytes.len) };
+                    }
+
+                    // we already checked it's all ascii
+                    _ = this.buffer.write(this.allocator, bytes) catch {
+                        return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                    };
+                } else if (this.buffer.len == 0) {
+                    // kinda fast path:
+                    // - combined chunk is large enough to flush automatically
+                    // - no backpressure
+                    const reported = this.buffer.writeLatin1(this.allocator, bytes) catch {
+                        return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                    };
+                    const readable = this.readableSlice();
+                    if (this.send(readable)) {
+                        this.handleWrote(readable.len);
+                        return .{ .owned = @as(Blob.SizeType, reported) };
+                    }
+                }
+
+                this.res.onWritable(*@This(), onWritable, this);
+            } else {
+                _ = this.buffer.writeLatin1(this.allocator, bytes) catch {
+                    return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                };
+            }
+
+            return .{ .owned = @truncate(Blob.SizeType, bytes.len) };
+        }
+        pub fn writeUTF16(this: *@This(), data: StreamResult) StreamResult.Writable {
+            if (this.done or this.requested_end) {
+                return .{ .owned = 0 };
+            }
+
+            if (this.res.hasResponded()) {
+                this.signal.close(null);
+                this.done = true;
+                return .{ .done = {} };
+            }
+
+            const bytes = data.slice();
+            var written: usize = undefined;
+            if (!this.hasBackpressure()) {
+                // we must always buffer UTF-16
+                // we assume the case of all-ascii UTF-16 string is pretty uncommon
+                written = this.buffer.writeUTF16(this.allocator, @alignCast(2, std.mem.bytesAsSlice(u16, bytes))) catch {
+                    return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                };
+
+                const readable = this.readableSlice();
+                if (this.send(readable)) {
+                    this.handleWrote(readable.len);
+                    return .{ .owned = @truncate(Blob.SizeType, written) };
+                }
+
+                this.res.onWritable(*@This(), onWritable, this);
+            } else {
+                written = this.buffer.writeUTF16(this.allocator, @alignCast(2, std.mem.bytesAsSlice(u16, bytes))) catch {
+                    return .{ .err = JSC.Node.Syscall.Error.fromCode(.NOMEM, .write) };
+                };
+            }
+
+            return .{ .owned = @truncate(Blob.SizeType, written) };
+        }
+
+        pub fn end(this: *@This(), err: ?JSC.Node.Syscall.Error) JSC.Node.Maybe(void) {
+            if (this.requested_end) {
+                return .{ .result = {} };
+            }
+
+            if (this.done or this.res.hasResponded()) {
+                this.signal.close(err);
+                this.done = true;
+                return .{ .result = {} };
+            }
+
+            this.requested_end = true;
+            const readable = this.readableSlice();
+            this.end_len = readable.len;
+
+            if (readable.len == 0) {
+                this.done = true;
+                this.res.end("", false);
+                return .{ .result = {} };
+            }
+
+            if (!this.hasBackpressure()) {
+                if (this.send(readable)) {
+                    this.handleWrote(readable.len);
+                    return .{ .result = {} };
+                }
+
+                this.res.onWritable(*@This(), onWritable, this);
+            }
+
+            return .{ .result = {} };
+        }
+
+        pub fn endFromJS(this: *@This(), globalThis: *JSGlobalObject) JSC.Node.Maybe(JSValue) {
+            if (this.requested_end) {
+                return .{ .result = JSC.JSValue.jsNumber(0) };
+            }
+
+            if (this.done or this.res.hasResponded()) {
+                this.signal.close(null);
+                this.done = true;
+                return .{ .result = JSC.JSValue.jsNumber(0) };
+            }
+
+            this.requested_end = true;
+            const readable = this.readableSlice();
+            this.end_len = readable.len;
+
+            if (readable.len == 0) {
+                this.done = true;
+                this.res.end("", false);
+                this.signal.close(null);
+                this.done = true;
+                return .{ .result = JSC.JSValue.jsNumber(0) };
+            }
+
+            if (!this.hasBackpressure()) {
+                if (this.send(readable)) {
+                    this.handleWrote(readable.len);
+                    this.signal.close(null);
+                    this.done = true;
+                    return .{ .result = JSC.JSValue.jsNumber(this.wrote) };
+                }
+
+                this.res.onWritable(*@This(), onWritable, this);
+            }
+
+            if (this.pending_drain) |prom| {
+                this.pending_drain = null;
+                return .{ .result = prom.asValue(globalThis) };
             }
-            return .{ .result = wrote };
+
+            this.pending_drain = JSC.JSPromise.create(globalThis);
+            this.globalThis = globalThis;
+            const value = this.pending_drain.?.asValue(globalThis);
+            value.protect();
+            return .{ .result = value };
+        }
+
+        pub fn sink(this: *@This()) Sink {
+            return Sink.init(this);
         }
 
-        // client-initiated
         pub fn onAborted(this: *@This(), _: *UWSResponse) void {
-            this.writable.didAbort();
+            this.signal.close(null);
+            this.done = true;
+            this.aborted = true;
+            this.flushPromise();
         }
-        // writer-initiated
-        pub fn onAbort(this: *@This()) void {
-            this.res.end("", true);
+
+        pub fn finalize(this: *@This()) void {
+            if (!this.done) {
+                this.done = true;
+                this.res.end("", false);
+            }
+
+            var bytes = this.buffer.listManaged(this.allocator);
+            bytes.deinit();
+            this.buffer.len = 0;
+            this.flushPromise();
         }
-        pub fn onClose(this: *@This()) void {
-            this.res.end("", false);
+
+        pub fn flushPromise(this: *@This()) void {
+            if (this.pending_drain) |prom| {
+                this.pending_drain = null;
+                prom.asValue(this.globalThis).unprotect();
+                prom.resolve(this.globalThis, JSC.JSValue.jsNumber(0));
+            }
         }
-        pub fn deinit(_: *@This()) void {}
 
-        pub const Writable = WritableStreamSink(@This(), onStart, onWrite, onAbort, onClose, deinit);
+        const name = if (ssl) "HTTPSResponseSink" else "HTTPResponseSink";
+        pub const JSSink = NewJSSink(@This(), name);
     };
 }
-pub const HTTPSWriter = HTTPServerWritable(true);
-pub const HTTPWriter = HTTPServerWritable(false);
+pub const HTTPSResponseSink = HTTPServerWritable(true);
+pub const HTTPResponseSink = HTTPServerWritable(false);
 
 pub fn ReadableStreamSource(
     comptime Context: type,
@@ -1739,6 +2177,7 @@ pub const FileBlobLoader = struct {
     scheduled_count: u32 = 0,
     concurrent: Concurrent = Concurrent{},
     input_tag: StreamResult.Tag = StreamResult.Tag.done,
+    started: bool = false,
 
     const FileReader = @This();
 
@@ -1920,7 +2359,7 @@ pub const FileBlobLoader = struct {
     pub fn scheduleAsync(this: *FileReader, chunk_size: Blob.SizeType) void {
         this.scheduled_count += 1;
         this.loop.virtual_machine.active_tasks +|= 1;
-
+        std.debug.assert(this.started);
         NetworkThread.init() catch {};
         this.concurrent.chunk_size = chunk_size;
         NetworkThread.global.pool.schedule(.{ .head = &this.concurrent.task, .tail = &this.concurrent.task, .len = 1 });
@@ -1930,6 +2369,8 @@ pub const FileBlobLoader = struct {
     const default_file_chunk_size = 1024 * 1024 * 2;
     pub fn onStart(this: *FileBlobLoader) StreamStart {
         var file = &this.store.data.file;
+        std.debug.assert(!this.started);
+        this.started = true;
         var file_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
         var auto_close = this.auto_close;
         defer this.auto_close = auto_close;
@@ -2027,6 +2468,7 @@ pub const FileBlobLoader = struct {
     pub fn onPullInto(this: *FileBlobLoader, buffer: []u8, view: JSC.JSValue) StreamResult {
         const chunk_size = this.calculateChunkSize(std.math.maxInt(usize));
         this.input_tag = .into_array;
+        std.debug.assert(this.started);
 
         switch (chunk_size) {
             0 => {
@@ -2061,6 +2503,8 @@ pub const FileBlobLoader = struct {
     }
 
     fn handleReadChunk(this: *FileBlobLoader, result: usize) StreamResult {
+        std.debug.assert(this.started);
+
         this.total_read += @intCast(Blob.SizeType, result);
         const remaining: Blob.SizeType = if (this.store.data.file.seekable orelse false)
             this.store.data.file.max_size -| this.total_read
@@ -2089,6 +2533,8 @@ pub const FileBlobLoader = struct {
         read_buf: []u8,
         view: JSC.JSValue,
     ) StreamResult {
+        std.debug.assert(this.started);
+
         const rc =
             JSC.Node.Syscall.read(this.fd, read_buf);
 
@@ -2125,6 +2571,7 @@ pub const FileBlobLoader = struct {
 
     pub fn callback(task: ?*anyopaque, sizeOrOffset: i64, _: u16) void {
         var this: *FileReader = bun.cast(*FileReader, task.?);
+        std.debug.assert(this.started);
         this.scheduled_count -= 1;
         const protected_view = this.protected_view;
         defer protected_view.unprotect();
diff --git a/src/global.zig b/src/global.zig
index d525b5d97..483c73514 100644
--- a/src/global.zig
+++ b/src/global.zig
@@ -105,6 +105,9 @@ pub inline fn constStrToU8(s: []const u8) []u8 {
 pub const MAX_PATH_BYTES: usize = if (Environment.isWasm) 1024 else std.fs.MAX_PATH_BYTES;
 
 pub inline fn cast(comptime To: type, value: anytype) To {
+    if (comptime std.meta.trait.isIntegral(@TypeOf(value))) {
+        return @intToPtr(To, @bitCast(usize, value));
+    }
     return @ptrCast(To, @alignCast(@alignOf(To), value));
 }
 
diff --git a/src/jsc.zig b/src/jsc.zig
index 04608477d..c06ec4022 100644
--- a/src/jsc.zig
+++ b/src/jsc.zig
@@ -42,6 +42,8 @@ pub const Node = struct {
     pub const fs = @import("./bun.js/node/node_fs_constant.zig");
 };
 pub const Maybe = Node.Maybe;
+pub const jsNumber = @This().JSValue.jsNumber;
+pub const jsBoolean = @This().JSValue.jsBoolean;
 pub inline fn markBinding() void {
     if (comptime is_bindgen) unreachable;
 }
diff --git a/src/json_parser.zig b/src/json_parser.zig
index 4bc442a5e..cecb26ba8 100644
--- a/src/json_parser.zig
+++ b/src/json_parser.zig
@@ -627,7 +627,7 @@ pub fn toAST(
                 return Expr{ .data = .{ .e_null = .{} }, .loc = logger.Loc{} };
             };
 
-            return toAST(allocator, string, std.mem.span(@tagName(value)));
+            return toAST(allocator, string, @as(string, @tagName(value)));
         },
         .ErrorSet => return try toAST(allocator, []const u8, std.mem.span(@errorName(value))),
         .Union => |Union| {
diff --git a/src/linker.zig b/src/linker.zig
index e67339216..63ed3ca0a 100644
--- a/src/linker.zig
+++ b/src/linker.zig
@@ -265,7 +265,7 @@ pub const Linker = struct {
                     if (comptime is_bun) {
                         if (JSC.HardcodedModule.LinkerMap.get(import_record.path.text)) |replacement| {
                             import_record.path.text = replacement;
-                            import_record.tag = .hardcoded;
+                            import_record.tag = if (strings.eqlComptime(replacement, "bun")) ImportRecord.Tag.bun else .hardcoded;
                             externals.append(record_index) catch unreachable;
                             continue;
                         }
diff --git a/src/router.zig b/src/router.zig
index 2ae4b98fb..b482cf18c 100644
--- a/src/router.zig
+++ b/src/router.zig
@@ -213,7 +213,7 @@ pub const Routes = struct {
     }
 
     fn match(this: *Routes, allocator: std.mem.Allocator, pathname_: string, comptime MatchContext: type, ctx: MatchContext) ?*Route {
-        var pathname = std.mem.trimLeft(u8, pathname_, "/");
+        const pathname = std.mem.trimLeft(u8, pathname_, "/");
 
         if (pathname.len == 0) {
             return this.index;
diff --git a/src/toml/toml_lexer.zig b/src/toml/toml_lexer.zig
index d54b64863..2ec11c72b 100644
--- a/src/toml/toml_lexer.zig
+++ b/src/toml/toml_lexer.zig
@@ -1110,7 +1110,7 @@ pub const Lexer = struct {
     }
 
     pub fn expected(self: *Lexer, token: T) !void {
-        try self.expectedString(std.mem.span(@tagName(token)));
+        try self.expectedString(@as(string, @tagName(token)));
     }
 
     pub fn unexpected(lexer: *Lexer) !void {
diff --git a/test/bun.js/bigint.test.js b/test/bun.js/bigint.test.js
new file mode 100644
index 000000000..ba71f3f9f
--- /dev/null
+++ b/test/bun.js/bigint.test.js
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "bun:test";
+
+it("BigInt compares correctly (literal)", () => {
+  expect(42n).toBe(42n);
+});
+
+it("BigInt compares correctly (object)", () => {
+  expect(BigInt(42n)).toBe(BigInt(42n));
+  expect(42n).toBe(BigInt(42n));
+  expect(BigInt(Bun.inspect(42n).substring(0, 2))).toBe(BigInt(42n));
+  expect(BigInt(42n).valueOf()).toBe(BigInt(42n));
+});
diff --git a/test/bun.js/serve.test.ts b/test/bun.js/serve.test.ts
index 8b785dd25..eddec6411 100644
--- a/test/bun.js/serve.test.ts
+++ b/test/bun.js/serve.test.ts
@@ -1,82 +1,208 @@
 import { file, serve } from "bun";
-import { expect, it } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import { readFileSync } from "fs";
 import { resolve } from "path";
 
 var port = 40000;
 
-it("should work for a hello world", async () => {
-  const server = serve({
-    port: port++,
-    fetch(req) {
-      return new Response(`Hello, world!`);
-    },
-  });
-  const response = await fetch(`http://localhost:${server.port}`);
-  expect(await response.text()).toBe("Hello, world!");
-  server.stop();
-});
+describe("streaming", () => {
+  it("text from JS, one chunk", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
 
-it("should work for a file", async () => {
-  const fixture = resolve(import.meta.dir, "./fetch.js.txt");
-  const textToExpect = readFileSync(fixture, "utf-8");
-
-  const server = serve({
-    port: port++,
-    fetch(req) {
-      return new Response(file(fixture));
-    },
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue(textToExpect);
+              controller.close();
+            },
+          })
+        );
+      },
+    });
+    console.log("fetching");
+    const response = await fetch(`http://localhost:${server.port}`);
+    console.log("finished");
+    const text = await response.text();
+    console.log(text, textToExpect, text === textToExpect);
+    expect(text).toBe(textToExpect);
+    console.log("done");
+    server.stop();
   });
-  const response = await fetch(`http://localhost:${server.port}`);
-  expect(await response.text()).toBe(textToExpect);
-  server.stop();
-});
+  it("text from JS, two chunks", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
 
-it("fetch should work with headers", async () => {
-  const fixture = resolve(import.meta.dir, "./fetch.js.txt");
-
-  const server = serve({
-    port: port++,
-    fetch(req) {
-      if (req.headers.get("X-Foo") !== "bar") {
-        return new Response("X-Foo header not set", { status: 500 });
-      }
-      return new Response(file(fixture), {
-        headers: { "X-Both-Ways": "1" },
-      });
-    },
-  });
-  const response = await fetch(`http://localhost:${server.port}`, {
-    headers: {
-      "X-Foo": "bar",
-    },
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              controller.enqueue(textToExpect.substring(100));
+              controller.close();
+            },
+          })
+        );
+      },
+    });
+    const response = await fetch(`http://localhost:${server.port}`);
+    expect(await response.text()).toBe(textToExpect);
+    server.stop();
   });
 
-  expect(response.status).toBe(200);
-  expect(response.headers.get("X-Both-Ways")).toBe("1");
-  server.stop();
-});
+  it("text from JS, 2 chunks, with delay", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
 
-var count = 200;
-it(`should work for a file ${count} times`, async () => {
-  const fixture = resolve(import.meta.dir, "./fetch.js.txt");
-  const textToExpect = readFileSync(fixture, "utf-8");
-  var ran = 0;
-  const server = serve({
-    port: port++,
-    async fetch(req) {
-      return new Response(file(fixture));
-    },
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              queueMicrotask(() => {
+                controller.enqueue(textToExpect.substring(100));
+                controller.close();
+              });
+            },
+          })
+        );
+      },
+    });
+    const response = await fetch(`http://localhost:${server.port}`);
+    expect(await response.text()).toBe(textToExpect);
+    server.stop();
   });
 
-  // this gets stuck if run about 200 times awaiting all the promises
-  // when the promises are run altogether, instead of one at a time
-  // it's hard to say if this only happens here due to some weird stuff with the test runner
-  // or if it's "real" issue
-  for (let i = 0; i < count; i++) {
+  it("text from JS, 2 chunks, with delay in pull", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
+
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            pull(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              queueMicrotask(() => {
+                controller.enqueue(textToExpect.substring(100));
+                controller.close();
+              });
+            },
+          })
+        );
+      },
+    });
     const response = await fetch(`http://localhost:${server.port}`);
     expect(await response.text()).toBe(textToExpect);
-  }
+    server.stop();
+  });
 
-  server.stop();
+  it("text from JS, 2 chunks, with async pull", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
+
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            async pull(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              await Promise.resolve();
+              controller.enqueue(textToExpect.substring(100));
+              await Promise.resolve();
+              controller.close();
+            },
+          })
+        );
+      },
+    });
+    const response = await fetch(`http://localhost:${server.port}`);
+    expect(await response.text()).toBe(textToExpect);
+    server.stop();
+  });
 });
+
+// it("should work for a hello world", async () => {
+//   const server = serve({
+//     port: port++,
+//     fetch(req) {
+//       return new Response(`Hello, world!`);
+//     },
+//   });
+//   const response = await fetch(`http://localhost:${server.port}`);
+//   expect(await response.text()).toBe("Hello, world!");
+//   server.stop();
+// });
+
+// it("should work for a file", async () => {
+//   const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+//   const textToExpect = readFileSync(fixture, "utf-8");
+
+//   const server = serve({
+//     port: port++,
+//     fetch(req) {
+//       return new Response(file(fixture));
+//     },
+//   });
+//   const response = await fetch(`http://localhost:${server.port}`);
+//   expect(await response.text()).toBe(textToExpect);
+//   server.stop();
+// });
+
+// it("fetch should work with headers", async () => {
+//   const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+
+//   const server = serve({
+//     port: port++,
+//     fetch(req) {
+//       if (req.headers.get("X-Foo") !== "bar") {
+//         return new Response("X-Foo header not set", { status: 500 });
+//       }
+//       return new Response(file(fixture), {
+//         headers: { "X-Both-Ways": "1" },
+//       });
+//     },
+//   });
+//   const response = await fetch(`http://localhost:${server.port}`, {
+//     headers: {
+//       "X-Foo": "bar",
+//     },
+//   });
+
+//   expect(response.status).toBe(200);
+//   expect(response.headers.get("X-Both-Ways")).toBe("1");
+//   server.stop();
+// });
+
+// var count = 200;
+// it(`should work for a file ${count} times`, async () => {
+//   const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+//   const textToExpect = readFileSync(fixture, "utf-8");
+//   var ran = 0;
+//   const server = serve({
+//     port: port++,
+//     async fetch(req) {
+//       return new Response(file(fixture));
+//     },
+//   });
+
+//   // this gets stuck if run about 200 times awaiting all the promises
+//   // when the promises are run altogether, instead of one at a time
+//   // it's hard to say if this only happens here due to some weird stuff with the test runner
+//   // or if it's "real" issue
+//   for (let i = 0; i < count; i++) {
+//     const response = await fetch(`http://localhost:${server.port}`);
+//     expect(await response.text()).toBe(textToExpect);
+//   }
+
+//   server.stop();
+// });
diff --git a/test/bun.js/streams.test.js b/test/bun.js/streams.test.js
index ccbea1d09..4e869aeaa 100644
--- a/test/bun.js/streams.test.js
+++ b/test/bun.js/streams.test.js
@@ -22,6 +22,21 @@ it("exists globally", () => {
   expect(typeof CountQueuingStrategy).toBe("function");
 });
 
+it("ReadableStream (readMany)", async () => {
+  var stream = new ReadableStream({
+    pull(controller) {
+      controller.enqueue("hello");
+      controller.enqueue("world");
+      controller.close();
+    },
+    cancel() {},
+  });
+  var reader = stream.getReader();
+  const chunk = await reader.readMany();
+  expect(chunk.value.join("")).toBe("helloworld");
+  expect((await reader.read()).done).toBe(true);
+});
+
 it("ReadableStream (direct)", async () => {
   var stream = new ReadableStream({
     pull(controller) {
diff --git a/types/bun/bun-test.d.ts b/types/bun/bun-test.d.ts
index 76ded893b..a464e7e09 100644
--- a/types/bun/bun-test.d.ts
+++ b/types/bun/bun-test.d.ts
@@ -18,7 +18,7 @@
  */
 
 declare module "bun:test" {
-  export function describe(label: string, body: () => {}): any;
+  export function describe(label: string, body: () => void): any;
   export function it(label: string, test: () => void | Promise<any>): any;
   export function test(label: string, test: () => void | Promise<any>): any;
 
diff --git a/types/bun/bun.d.ts b/types/bun/bun.d.ts
index 85b7762ef..76d541f62 100644
--- a/types/bun/bun.d.ts
+++ b/types/bun/bun.d.ts
@@ -310,7 +310,7 @@ declare module "bun" {
    * Convert a {@link URL} to a filesystem path.
    * @param url The URL to convert.
    * @returns A filesystem path.
-   * @throws If the URL is not a file:// URL.
+   * @throws If the URL is not a URL.
    * @example
    * ```js
    * const path = Bun.fileURLToPath(new URL("file:///foo/bar.txt"));
@@ -319,6 +319,23 @@ declare module "bun" {
    */
   export function fileURLToPath(url: URL): string;
 
+  interface Sink<T> {
+    write(chunk: string | ArrayBufferView | ArrayBuffer): number;
+    drain(): Promise<number> | number;
+    end(): T;
+  }
+
+  /**
+   * Fast incremental writer that becomes an ArrayBuffer on end().
+   */
+  export class ArrayBufferSink implements Sink<ArrayBuffer> {
+    constructor({ stream = false, asUint8Array = false, highWaterMark = 2048 });
+
+    write(chunk: string | ArrayBufferView | ArrayBuffer): number;
+    drain(): number;
+    end(): ArrayBuffer;
+  }
+
   /**
    * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) powered by the fastest system calls available for operating on files.
    *