Regenerate builtins

4 files changed, 150 insertions, 88 deletions

diff --git a/src/bun.js/builtins/cpp/ReadableStreamBuiltins.cpp b/src/bun.js/builtins/cpp/ReadableStreamBuiltins.cpp
index d60f09e7b..3ce80f2f9 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 = 2783;
+const int s_readableStreamInitializeReadableStreamCodeLength = 3256;
 static const JSC::Intrinsic s_readableStreamInitializeReadableStreamCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamInitializeReadableStreamCode =
     "(function (underlyingSource, strategy)\n" \
@@ -74,6 +74,7 @@ const char* const s_readableStreamInitializeReadableStreamCode =
     "    @putByIdDirectPrivate(this, \"storedError\", @undefined);\n" \
     "    \n" \
     "    @putByIdDirectPrivate(this, \"disturbed\", false);\n" \
+    "\n" \
     "    \n" \
     "    //\n" \
     "    @putByIdDirectPrivate(this, \"readableStreamController\", null);\n" \
@@ -90,6 +91,7 @@ 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, \"highWaterMark\", 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" \
@@ -97,10 +99,13 @@ const char* const s_readableStreamInitializeReadableStreamCode =
     "    }\n" \
     "    if (isDirect) {\n" \
     "        @putByIdDirectPrivate(this, \"underlyingSource\", underlyingSource);\n" \
+    "        @putByIdDirectPrivate(this, \"highWaterMark\", @getByIdDirectPrivate(strategy, \"highWaterMark\"));\n" \
     "        @putByIdDirectPrivate(this, \"start\", () => @createReadableStreamController(this, underlyingSource, strategy));\n" \
     "    } else if (isLazy) {\n" \
     "        const autoAllocateChunkSize = underlyingSource.autoAllocateChunkSize;\n" \
+    "        @putByIdDirectPrivate(this, \"highWaterMark\", @undefined);\n" \
     "        @putByIdDirectPrivate(this, \"underlyingSource\", @undefined);\n" \
+    "        @putByIdDirectPrivate(this, \"highWaterMark\", autoAllocateChunkSize || @getByIdDirectPrivate(strategy, \"highWaterMark\"));\n" \
     "\n" \
     "        \n" \
     "        @putByIdDirectPrivate(this, \"start\", () => {\n" \
@@ -111,6 +116,7 @@ const char* const s_readableStreamInitializeReadableStreamCode =
     "        });\n" \
     "    } else {\n" \
     "        @putByIdDirectPrivate(this, \"underlyingSource\", @undefined);\n" \
+    "        @putByIdDirectPrivate(this, \"highWaterMark\", @getByIdDirectPrivate(strategy, \"highWaterMark\"));\n" \
     "        @putByIdDirectPrivate(this, \"start\", @undefined);\n" \
     "        @createReadableStreamController(this, underlyingSource, strategy);\n" \
     "    }\n" \
@@ -122,48 +128,60 @@ const char* const s_readableStreamInitializeReadableStreamCode =
 
 const JSC::ConstructAbility s_readableStreamReadableStreamToArrayCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamReadableStreamToArrayCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamReadableStreamToArrayCodeLength = 883;
+const int s_readableStreamReadableStreamToArrayCodeLength = 1366;
 static const JSC::Intrinsic s_readableStreamReadableStreamToArrayCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamReadableStreamToArrayCode =
     "(function (stream) {\n" \
     "    \"use strict\";\n" \
     "\n" \
-    "    if (!stream || @getByIdDirectPrivate(stream, \"state\") === @streamClosed) {\n" \
-    "        return null;\n" \
+    "    //\n" \
+    "    var underlyingSource = @getByIdDirectPrivate(stream, \"underlyingSource\");\n" \
+    "    if (underlyingSource !== @undefined) {    \n" \
+    "        const promise = @initializeArrayStream.@call(stream, underlyingSource, @undefined);\n" \
+    "        var reader = stream.getReader();\n" \
+    "        return (async function() {\n" \
+    "            while (@getByIdDirectPrivate(stream, \"state\") === @streamReadable) {\n" \
+    "                var thisResult = await reader.read();\n" \
+    "                if (thisResult.done) {\n" \
+    "                    break;\n" \
+    "                }\n" \
+    "            }\n" \
+    "\n" \
+    "            try {\n" \
+    "                reader.releaseLock();\n" \
+    "            } catch(e) {\n" \
+    "            }\n" \
+    "\n" \
+    "            return await promise;\n" \
+    "        })();\n" \
     "    }\n" \
+    "\n" \
     "    var reader = stream.getReader();\n" \
     "    var manyResult = reader.readMany();\n" \
     "    \n" \
     "    async function processManyResult(result) {\n" \
     "        \n" \
     "        if (result.done) {\n" \
-    "            return null;\n" \
+    "            return [];\n" \
     "        }\n" \
     "\n" \
     "        var chunks = result.value || [];\n" \
     "        \n" \
     "        while (true) {\n" \
     "            var thisResult = await reader.read();\n" \
-    "            \n" \
     "            if (thisResult.done) {\n" \
-    "                return chunks;\n" \
+    "                break;\n" \
     "            }\n" \
-    "            \n" \
-    "            chunks.push(thisResult.value);\n" \
+    "            chunks = chunks.concat(thisResult.value);\n" \
     "        }\n" \
     "\n" \
     "        return chunks;\n" \
-    "    };\n" \
-    "\n" \
+    "    }\n" \
     "\n" \
     "    if (manyResult && @isPromise(manyResult)) {\n" \
     "        return manyResult.@then(processManyResult);\n" \
     "    }\n" \
     "\n" \
-    "    if (manyResult && manyResult.done) {\n" \
-    "        return null;\n" \
-    "    }\n" \
-    "\n" \
     "    return processManyResult(manyResult);\n" \
     "})\n" \
 ;
@@ -213,13 +231,12 @@ const char* const s_readableStreamReadableStreamToTextCode =
 
 const JSC::ConstructAbility s_readableStreamReadableStreamToJSONCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamReadableStreamToJSONCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamReadableStreamToJSONCodeLength = 121;
+const int s_readableStreamReadableStreamToJSONCodeLength = 114;
 static const JSC::Intrinsic s_readableStreamReadableStreamToJSONCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamReadableStreamToJSONCode =
     "(function (stream) {\n" \
     "    \"use strict\";\n" \
     "\n" \
-    "    //\n" \
     "    return @readableStreamToText(stream).@then(globalThis.JSON.parse);\n" \
     "})\n" \
 ;
@@ -260,53 +277,6 @@ const char* const s_readableStreamReadableStreamToBlobCode =
     "})\n" \
 ;
 
-const JSC::ConstructAbility s_readableStreamReadableStreamToArrayPublicCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
-const JSC::ConstructorKind s_readableStreamReadableStreamToArrayPublicCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamReadableStreamToArrayPublicCodeLength = 841;
-static const JSC::Intrinsic s_readableStreamReadableStreamToArrayPublicCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_readableStreamReadableStreamToArrayPublicCode =
-    "(function (stream) {\n" \
-    "    \"use strict\";\n" \
-    "\n" \
-    "    if (@getByIdDirectPrivate(stream, \"state\") === @streamClosed) {\n" \
-    "        return [];\n" \
-    "    }\n" \
-    "    var reader = stream.getReader();\n" \
-    "\n" \
-    "    var manyResult = reader.readMany();\n" \
-    "\n" \
-    "    var processManyResult = (0, (async function(result) {\n" \
-    "        if (result.done) {\n" \
-    "            return [];\n" \
-    "        }\n" \
-    "\n" \
-    "        var chunks = result.value || [];\n" \
-    "        \n" \
-    "        while (true) {\n" \
-    "            var thisResult = await reader.read();\n" \
-    "            if (thisResult.done) {\n" \
-    "                return chunks;\n" \
-    "            }\n" \
-    "\n" \
-    "            chunks.push(thisResult.value);\n" \
-    "        }\n" \
-    "\n" \
-    "        return chunks;\n" \
-    "    }));\n" \
-    "\n" \
-    "\n" \
-    "    if (manyResult && @isPromise(manyResult)) {\n" \
-    "        return manyResult.then(processManyResult);\n" \
-    "    }\n" \
-    "\n" \
-    "    if (manyResult && manyResult.done) {\n" \
-    "        return [];\n" \
-    "    }\n" \
-    "\n" \
-    "    return processManyResult(manyResult);\n" \
-    "})\n" \
-;
-
 const JSC::ConstructAbility s_readableStreamConsumeReadableStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamConsumeReadableStreamCodeConstructorKind = JSC::ConstructorKind::None;
 const int s_readableStreamConsumeReadableStreamCodeLength = 3718;
diff --git a/src/bun.js/builtins/cpp/ReadableStreamBuiltins.h b/src/bun.js/builtins/cpp/ReadableStreamBuiltins.h
index d009f8560..4f6f146d1 100644
--- a/src/bun.js/builtins/cpp/ReadableStreamBuiltins.h
+++ b/src/bun.js/builtins/cpp/ReadableStreamBuiltins.h
@@ -67,10 +67,6 @@ extern const char* const s_readableStreamReadableStreamToBlobCode;
 extern const int s_readableStreamReadableStreamToBlobCodeLength;
 extern const JSC::ConstructAbility s_readableStreamReadableStreamToBlobCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamReadableStreamToBlobCodeConstructorKind;
-extern const char* const s_readableStreamReadableStreamToArrayPublicCode;
-extern const int s_readableStreamReadableStreamToArrayPublicCodeLength;
-extern const JSC::ConstructAbility s_readableStreamReadableStreamToArrayPublicCodeConstructAbility;
-extern const JSC::ConstructorKind s_readableStreamReadableStreamToArrayPublicCodeConstructorKind;
 extern const char* const s_readableStreamConsumeReadableStreamCode;
 extern const int s_readableStreamConsumeReadableStreamCodeLength;
 extern const JSC::ConstructAbility s_readableStreamConsumeReadableStreamCodeConstructAbility;
@@ -114,7 +110,6 @@ extern const JSC::ConstructorKind s_readableStreamLockedCodeConstructorKind;
     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) \
@@ -130,7 +125,6 @@ extern const JSC::ConstructorKind s_readableStreamLockedCodeConstructorKind;
 #define WEBCORE_BUILTIN_READABLESTREAM_READABLESTREAMTOTEXT 1
 #define WEBCORE_BUILTIN_READABLESTREAM_READABLESTREAMTOJSON 1
 #define WEBCORE_BUILTIN_READABLESTREAM_READABLESTREAMTOBLOB 1
-#define WEBCORE_BUILTIN_READABLESTREAM_READABLESTREAMTOARRAYPUBLIC 1
 #define WEBCORE_BUILTIN_READABLESTREAM_CONSUMEREADABLESTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAM_CREATEEMPTYREADABLESTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAM_CREATENATIVEREADABLESTREAM 1
@@ -147,7 +141,6 @@ extern const JSC::ConstructorKind s_readableStreamLockedCodeConstructorKind;
     macro(readableStreamReadableStreamToTextCode, readableStreamToText, ASCIILiteral(), s_readableStreamReadableStreamToTextCodeLength) \
     macro(readableStreamReadableStreamToJSONCode, readableStreamToJSON, ASCIILiteral(), s_readableStreamReadableStreamToJSONCodeLength) \
     macro(readableStreamReadableStreamToBlobCode, readableStreamToBlob, ASCIILiteral(), s_readableStreamReadableStreamToBlobCodeLength) \
-    macro(readableStreamReadableStreamToArrayPublicCode, readableStreamToArrayPublic, ASCIILiteral(), s_readableStreamReadableStreamToArrayPublicCodeLength) \
     macro(readableStreamConsumeReadableStreamCode, consumeReadableStream, ASCIILiteral(), s_readableStreamConsumeReadableStreamCodeLength) \
     macro(readableStreamCreateEmptyReadableStreamCode, createEmptyReadableStream, ASCIILiteral(), s_readableStreamCreateEmptyReadableStreamCodeLength) \
     macro(readableStreamCreateNativeReadableStreamCode, createNativeReadableStream, ASCIILiteral(), s_readableStreamCreateNativeReadableStreamCodeLength) \
@@ -169,7 +162,6 @@ extern const JSC::ConstructorKind s_readableStreamLockedCodeConstructorKind;
     macro(pipeThrough) \
     macro(pipeTo) \
     macro(readableStreamToArray) \
-    macro(readableStreamToArrayPublic) \
     macro(readableStreamToBlob) \
     macro(readableStreamToJSON) \
     macro(readableStreamToText) \
diff --git a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp
index 982c9567d..d7720424a 100644
--- a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp
+++ b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.cpp
@@ -764,7 +764,7 @@ const char* const s_readableStreamInternalsIsReadableStreamDefaultControllerCode
 
 const JSC::ConstructAbility s_readableStreamInternalsAssignToStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInternalsAssignToStreamCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamInternalsAssignToStreamCodeLength = 2607;
+const int s_readableStreamInternalsAssignToStreamCodeLength = 2945;
 static const JSC::Intrinsic s_readableStreamInternalsAssignToStreamCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamInternalsAssignToStreamCode =
     "(function (stream, sink) {\n" \
@@ -802,8 +802,17 @@ const char* const s_readableStreamInternalsAssignToStreamCode =
     "        @putByIdDirectPrivate(stream, \"start\", @undefined);\n" \
     "        @putByIdDirectPrivate(stream, \"underlyingSource\", @undefined);\n" \
     "\n" \
-    "        @startDirectStream.@call(sink, stream, pull, close);\n" \
+    "        const highWaterMark = @getByIdDirectPrivate(stream, \"highWaterMark\");\n" \
     "\n" \
+    "        if (highWaterMark) {\n" \
+    "            sink.start({\n" \
+    "                highWaterMark,\n" \
+    "            });\n" \
+    "        }\n" \
+    "\n" \
+    "        @startDirectStream.@call(sink, stream, pull, close);\n" \
+    "    \n" \
+    "        \n" \
     "        //\n" \
     "        reader = stream.getReader();\n" \
     "\n" \
@@ -831,7 +840,11 @@ const char* const s_readableStreamInternalsAssignToStreamCode =
     "\n" \
     "            \n" \
     "            var wroteCount = many.value.length;\n" \
-    "            sink.start();\n" \
+    "            const highWaterMark = @getByIdDirectPrivate(stream, \"highWaterMark\");\n" \
+    "\n" \
+    "            if (highWaterMark)\n" \
+    "                sink.start({highWaterMark});\n" \
+    "\n" \
     "            for (var i = 0, values = many.value, length = many.value.length; i < length; i++) {\n" \
     "                sink.write(values[i]);\n" \
     "            }\n" \
@@ -1149,7 +1162,7 @@ const char* const s_readableStreamInternalsOnDrainDirectStreamCode =
 
 const JSC::ConstructAbility s_readableStreamInternalsInitializeTextStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInternalsInitializeTextStreamCodeConstructorKind = JSC::ConstructorKind::None;
-const int s_readableStreamInternalsInitializeTextStreamCodeLength = 3832;
+const int s_readableStreamInternalsInitializeTextStreamCodeLength = 3957;
 static const JSC::Intrinsic s_readableStreamInternalsInitializeTextStreamCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamInternalsInitializeTextStreamCode =
     "(function (underlyingSource, highWaterMark)\n" \
@@ -1161,30 +1174,35 @@ const char* const s_readableStreamInternalsInitializeTextStreamCode =
     "    var hasString = false;\n" \
     "    var hasBuffer = false;\n" \
     "    var rope = '';\n" \
-    "    var estimatedLength = 0;\n" \
+    "    var estimatedLength = @toLength(0);\n" \
     "    var closingPromise = @newPromise();\n" \
     "    var calledDone = false;\n" \
-    "    var sink = {\n" \
+    "    var isView = @ArrayBuffer.@isView;\n" \
+    "    \n" \
+    "\n" \
+    "    sink = {\n" \
     "        start() {\n" \
     "\n" \
     "        },\n" \
     "        write(chunk) {\n" \
     "            if (typeof chunk === 'string') {\n" \
-    "                if (chunk.length > 0) {\n" \
+    "                var chunkLength = @toLength(chunk.length);\n" \
+    "                if (chunkLength > 0) {\n" \
     "                    rope += chunk;\n" \
     "                    hasString = true;\n" \
-    "                    estimatedLength += chunk.length;\n" \
-    "                    //\n" \
+    "                     //\n" \
+    "                    estimatedLength += chunkLength;\n" \
+    "                   \n" \
     "                }\n" \
     "\n" \
-    "                return chunk.length;\n" \
+    "                return chunkLength;\n" \
     "            }\n" \
     "\n" \
-    "            if (!chunk || !@isObject(chunk) || !(@ArrayBuffer.@isView(chunk) || chunk instanceof @ArrayBuffer)) {\n" \
+    "            if (!chunk || !@isObject(chunk) || !((isView(chunk)) || chunk instanceof @ArrayBuffer)) {\n" \
     "                @throwTypeError(\"Expected text, ArrayBuffer or ArrayBufferView\");\n" \
     "            }\n" \
     "\n" \
-    "            const byteLength = chunk.byteLength;\n" \
+    "            const byteLength = @toLength(chunk.byteLength);\n" \
     "            if (byteLength > 0) {\n" \
     "                hasBuffer = true;\n" \
     "                if (rope.length > 0) {\n" \
@@ -1246,7 +1264,8 @@ const char* const s_readableStreamInternalsInitializeTextStreamCode =
     "            if (rope.length > 0) {\n" \
     "                arrayBufferSink.write(rope);\n" \
     "            }\n" \
-    "\n" \
+    "            \n" \
+    "            //\n" \
     "            return new globalThis.TextDecoder().decode(\n" \
     "                arrayBufferSink.end()\n" \
     "            );\n" \
@@ -1261,7 +1280,6 @@ const char* const s_readableStreamInternalsInitializeTextStreamCode =
     "            } catch(e) {\n" \
     "\n" \
     "            } finally {\n" \
-    "                fifo.clear();\n" \
     "                rope = '';\n" \
     "                hasString = false;\n" \
     "                hasBuffer = false;\n" \
@@ -1296,9 +1314,81 @@ const char* const s_readableStreamInternalsInitializeTextStreamCode =
     "})\n" \
 ;
 
+const JSC::ConstructAbility s_readableStreamInternalsInitializeArrayStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
+const JSC::ConstructorKind s_readableStreamInternalsInitializeArrayStreamCodeConstructorKind = JSC::ConstructorKind::None;
+const int s_readableStreamInternalsInitializeArrayStreamCodeLength = 1496;
+static const JSC::Intrinsic s_readableStreamInternalsInitializeArrayStreamCodeIntrinsic = JSC::NoIntrinsic;
+const char* const s_readableStreamInternalsInitializeArrayStreamCode =
+    "(function (underlyingSource, highWaterMark)\n" \
+    "{\n" \
+    "    \"use strict\";\n" \
+    "\n" \
+    "    var array = [];\n" \
+    "    var closingPromise = @newPromise();\n" \
+    "    var calledDone = false;\n" \
+    "    \n" \
+    "    function fulfill() {\n" \
+    "        calledDone = true;\n" \
+    "        @fulfillPromise(closingPromise, array);\n" \
+    "        return array;\n" \
+    "    }\n" \
+    "\n" \
+    "    var sink = {\n" \
+    "        start() {\n" \
+    "\n" \
+    "        },\n" \
+    "        write(chunk) {\n" \
+    "            array.push(chunk);\n" \
+    "            return chunk.length;\n" \
+    "        },\n" \
+    "\n" \
+    "        drain() {\n" \
+    "            return 0;\n" \
+    "        },\n" \
+    "\n" \
+    "        end() {\n" \
+    "            if (calledDone) {\n" \
+    "                return [];\n" \
+    "            }\n" \
+    "            return fulfill();\n" \
+    "        },\n" \
+    "\n" \
+    "        close() {\n" \
+    "            if (!calledDone) {\n" \
+    "                fulfill();\n" \
+    "            }\n" \
+    "        }\n" \
+    "    };\n" \
+    "\n" \
+    "    var controller = {\n" \
+    "        @underlyingSource: underlyingSource,\n" \
+    "        @pull: @onPullDirectStream,\n" \
+    "        @controlledReadableStream: this,\n" \
+    "        @sink: sink,\n" \
+    "        close: @onCloseDirectStream,\n" \
+    "        write: sink.write,\n" \
+    "        error: @handleDirectStreamError,\n" \
+    "        end: @onCloseDirectStream,\n" \
+    "        @close: @onCloseDirectStream,\n" \
+    "        drain: @onDrainDirectStream,\n" \
+    "        _pendingRead: @undefined,\n" \
+    "        _deferClose: 0,\n" \
+    "        _deferDrain: 0,\n" \
+    "        _deferCloseReason: @undefined,\n" \
+    "        _handleError: @undefined,\n" \
+    "    };\n" \
+    "   \n" \
+    "    \n" \
+    "    @putByIdDirectPrivate(this, \"readableStreamController\", controller);\n" \
+    "    @putByIdDirectPrivate(this, \"underlyingSource\", @undefined);\n" \
+    "    @putByIdDirectPrivate(this, \"start\", @undefined);\n" \
+    "    return closingPromise;\n" \
+    "})\n" \
+;
+
 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 = 1086;
 static const JSC::Intrinsic s_readableStreamInternalsInitializeArrayBufferStreamCodeIntrinsic = JSC::NoIntrinsic;
 const char* const s_readableStreamInternalsInitializeArrayBufferStreamCode =
     "(function (underlyingSource, highWaterMark)\n" \
@@ -1309,7 +1399,7 @@ const char* const s_readableStreamInternalsInitializeArrayBufferStreamCode =
     "    //\n" \
     "    //\n" \
     "    \n" \
-    "    var opts = highWaterMark ? {highWaterMark, stream: true, asUint8Array: true} : {stream: true, asUint8Array: true};\n" \
+    "    var opts = highWaterMark && typeof highWaterMark === 'number' ? {highWaterMark, stream: true, asUint8Array: true} : {stream: true, asUint8Array: true};\n" \
     "    var sink = new globalThis.Bun.ArrayBufferSink();\n" \
     "    sink.start(opts);\n" \
     "\n" \
@@ -1333,6 +1423,8 @@ const char* const s_readableStreamInternalsInitializeArrayBufferStreamCode =
     "   \n" \
     "    \n" \
     "    @putByIdDirectPrivate(this, \"readableStreamController\", controller);\n" \
+    "    @putByIdDirectPrivate(this, \"underlyingSource\", @undefined);\n" \
+    "    @putByIdDirectPrivate(this, \"start\", @undefined);\n" \
     "    \n" \
     "})\n" \
 ;
diff --git a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h
index aeb20ff86..b8a17b8d3 100644
--- a/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h
+++ b/src/bun.js/builtins/cpp/ReadableStreamInternalsBuiltins.h
@@ -183,6 +183,10 @@ extern const char* const s_readableStreamInternalsInitializeTextStreamCode;
 extern const int s_readableStreamInternalsInitializeTextStreamCodeLength;
 extern const JSC::ConstructAbility s_readableStreamInternalsInitializeTextStreamCodeConstructAbility;
 extern const JSC::ConstructorKind s_readableStreamInternalsInitializeTextStreamCodeConstructorKind;
+extern const char* const s_readableStreamInternalsInitializeArrayStreamCode;
+extern const int s_readableStreamInternalsInitializeArrayStreamCodeLength;
+extern const JSC::ConstructAbility s_readableStreamInternalsInitializeArrayStreamCodeConstructAbility;
+extern const JSC::ConstructorKind s_readableStreamInternalsInitializeArrayStreamCodeConstructorKind;
 extern const char* const s_readableStreamInternalsInitializeArrayBufferStreamCode;
 extern const int s_readableStreamInternalsInitializeArrayBufferStreamCodeLength;
 extern const JSC::ConstructAbility s_readableStreamInternalsInitializeArrayBufferStreamCodeConstructAbility;
@@ -299,6 +303,7 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
     macro(onCloseDirectStream, readableStreamInternalsOnCloseDirectStream, 1) \
     macro(onDrainDirectStream, readableStreamInternalsOnDrainDirectStream, 0) \
     macro(initializeTextStream, readableStreamInternalsInitializeTextStream, 2) \
+    macro(initializeArrayStream, readableStreamInternalsInitializeArrayStream, 2) \
     macro(initializeArrayBufferStream, readableStreamInternalsInitializeArrayBufferStream, 2) \
     macro(readableStreamError, readableStreamInternalsReadableStreamError, 2) \
     macro(readableStreamDefaultControllerShouldCallPull, readableStreamInternalsReadableStreamDefaultControllerShouldCallPull, 1) \
@@ -354,6 +359,7 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ONCLOSEDIRECTSTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_ONDRAINDIRECTSTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_INITIALIZETEXTSTREAM 1
+#define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_INITIALIZEARRAYSTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_INITIALIZEARRAYBUFFERSTREAM 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_READABLESTREAMERROR 1
 #define WEBCORE_BUILTIN_READABLESTREAMINTERNALS_READABLESTREAMDEFAULTCONTROLLERSHOULDCALLPULL 1
@@ -410,6 +416,7 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
     macro(readableStreamInternalsOnCloseDirectStreamCode, onCloseDirectStream, ASCIILiteral(), s_readableStreamInternalsOnCloseDirectStreamCodeLength) \
     macro(readableStreamInternalsOnDrainDirectStreamCode, onDrainDirectStream, ASCIILiteral(), s_readableStreamInternalsOnDrainDirectStreamCodeLength) \
     macro(readableStreamInternalsInitializeTextStreamCode, initializeTextStream, ASCIILiteral(), s_readableStreamInternalsInitializeTextStreamCodeLength) \
+    macro(readableStreamInternalsInitializeArrayStreamCode, initializeArrayStream, ASCIILiteral(), s_readableStreamInternalsInitializeArrayStreamCodeLength) \
     macro(readableStreamInternalsInitializeArrayBufferStreamCode, initializeArrayBufferStream, ASCIILiteral(), s_readableStreamInternalsInitializeArrayBufferStreamCodeLength) \
     macro(readableStreamInternalsReadableStreamErrorCode, readableStreamError, ASCIILiteral(), s_readableStreamInternalsReadableStreamErrorCodeLength) \
     macro(readableStreamInternalsReadableStreamDefaultControllerShouldCallPullCode, readableStreamDefaultControllerShouldCallPull, ASCIILiteral(), s_readableStreamInternalsReadableStreamDefaultControllerShouldCallPullCodeLength) \
@@ -438,6 +445,7 @@ extern const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeCon
     macro(handleDirectStreamError) \
     macro(handleDirectStreamErrorReject) \
     macro(initializeArrayBufferStream) \
+    macro(initializeArrayStream) \
     macro(initializeTextStream) \
     macro(isReadableStream) \
     macro(isReadableStreamDefaultController) \