diff --git a/src/js/builtins/ReadableStreamInternals.ts b/src/js/builtins/ReadableStreamInternals.ts
index 58fa4524a9..dfd8b90085 100644
--- a/src/js/builtins/ReadableStreamInternals.ts
+++ b/src/js/builtins/ReadableStreamInternals.ts
@@ -500,11 +500,13 @@ export function readableStreamTee(stream, shouldClone) {
   const reader = new $ReadableStreamDefaultReader(stream);
 
   const teeState = {
-    closedOrErrored: false,
+    stream: stream,
     canceled1: false,
     canceled2: false,
     reason1: undefined,
     reason2: undefined,
+    reading: false,
+    readAgain: false,
   };
 
   teeState.cancelPromiseCapability = $newPromiseCapability(Promise);
@@ -523,10 +525,8 @@ export function readableStreamTee(stream, shouldClone) {
   const branch2 = new $ReadableStream(branch2Source);
 
   $getByIdDirectPrivate(reader, "closedPromiseCapability").promise.$then(undefined, function (e) {
-    if (teeState.closedOrErrored) return;
     $readableStreamDefaultControllerError(branch1.$readableStreamController, e);
     $readableStreamDefaultControllerError(branch2.$readableStreamController, e);
-    teeState.closedOrErrored = true;
     if (!teeState.canceled1 || !teeState.canceled2) teeState.cancelPromiseCapability.resolve.$call();
   });
 
@@ -538,26 +538,64 @@ export function readableStreamTee(stream, shouldClone) {
 }
 
 export function readableStreamTeePullFunction(teeState, reader, shouldClone) {
-  return function () {
-    Promise.prototype.$then.$call($readableStreamDefaultReaderRead(reader), function (result) {
-      $assert($isObject(result));
-      $assert(typeof result.done === "boolean");
-      if (result.done && !teeState.closedOrErrored) {
-        if (!teeState.canceled1) $readableStreamDefaultControllerClose(teeState.branch1.$readableStreamController);
-        if (!teeState.canceled2) $readableStreamDefaultControllerClose(teeState.branch2.$readableStreamController);
-        teeState.closedOrErrored = true;
-        if (!teeState.canceled1 || !teeState.canceled2) teeState.cancelPromiseCapability.resolve.$call();
-      }
-      if (teeState.closedOrErrored) return;
-      if (!teeState.canceled1)
-        $readableStreamDefaultControllerEnqueue(teeState.branch1.$readableStreamController, result.value);
-      if (!teeState.canceled2)
-        $readableStreamDefaultControllerEnqueue(
-          teeState.branch2.$readableStreamController,
-          shouldClone ? $structuredCloneForStream(result.value) : result.value,
-        );
-    });
+  var pullAlgorithm;
+  pullAlgorithm = function () {
+    if (teeState.reading) {
+      teeState.readAgain = true;
+      return Promise.resolve();
+    }
+    teeState.reading = true;
+    Promise.prototype.$then.$call(
+      $readableStreamDefaultReaderRead(reader),
+      function (result) {
+        $assert($isObject(result));
+        $assert(typeof result.done === "boolean");
+        if (result.done) {
+          // close steps.
+          teeState.reading = false;
+          if (!teeState.canceled1) $readableStreamDefaultControllerClose(teeState.branch1.$readableStreamController);
+          if (!teeState.canceled2) $readableStreamDefaultControllerClose(teeState.branch2.$readableStreamController);
+          if (!teeState.canceled1 || !teeState.canceled2) teeState.cancelPromiseCapability.resolve.$call();
+          return;
+        }
+        // chunk steps.
+        teeState.readAgain = false;
+        let chunk1 = result.value;
+        let chunk2 = chunk1;
+        if (!teeState.canceled2 && shouldClone && typeof chunk1 !== "string") {
+          try {
+            chunk2 = $structuredCloneForStream(chunk1);
+          } catch (e) {
+            $readableStreamDefaultControllerError(teeState.branch1.$readableStreamController, e);
+            $readableStreamDefaultControllerError(teeState.branch2.$readableStreamController, e);
+            $readableStreamCancel(teeState.stream, e).$then(
+              teeState.cancelPromiseCapability.resolve,
+              teeState.cancelPromiseCapability.reject,
+            );
+            return;
+          }
+        }
+
+        if (!teeState.canceled1) {
+          $readableStreamDefaultControllerEnqueue(teeState.branch1.$readableStreamController, chunk1);
+        }
+        if (!teeState.canceled2) {
+          $readableStreamDefaultControllerEnqueue(teeState.branch2.$readableStreamController, chunk2);
+        }
+        teeState.reading = false;
+
+        Promise.resolve().$then(() => {
+          if (teeState.readAgain) pullAlgorithm();
+        });
+      },
+      () => {
+        // error steps.
+        teeState.reading = false;
+      },
+    );
+    return Promise.resolve();
   };
+  return pullAlgorithm;
 }
 
 export function readableStreamTeeBranch1CancelFunction(teeState, stream) {
@@ -566,8 +604,8 @@ export function readableStreamTeeBranch1CancelFunction(teeState, stream) {
     teeState.reason1 = r;
     if (teeState.canceled2) {
       $readableStreamCancel(stream, [teeState.reason1, teeState.reason2]).$then(
-        teeState.cancelPromiseCapability.$resolve,
-        teeState.cancelPromiseCapability.$reject,
+        teeState.cancelPromiseCapability.resolve,
+        teeState.cancelPromiseCapability.reject,
       );
     }
     return teeState.cancelPromiseCapability.promise;
@@ -580,8 +618,8 @@ export function readableStreamTeeBranch2CancelFunction(teeState, stream) {
     teeState.reason2 = r;
     if (teeState.canceled1) {
       $readableStreamCancel(stream, [teeState.reason1, teeState.reason2]).$then(
-        teeState.cancelPromiseCapability.$resolve,
-        teeState.cancelPromiseCapability.$reject,
+        teeState.cancelPromiseCapability.resolve,
+        teeState.cancelPromiseCapability.reject,
       );
     }
     return teeState.cancelPromiseCapability.promise;
diff --git a/src/js/out/WebCoreJSBuiltins.cpp b/src/js/out/WebCoreJSBuiltins.cpp
index a28464a574..907f8f637a 100644
--- a/src/js/out/WebCoreJSBuiltins.cpp
+++ b/src/js/out/WebCoreJSBuiltins.cpp
@@ -580,9 +580,9 @@ const char* const s_transformStreamInternalsTransformStreamDefaultControllerErro
 const JSC::ConstructAbility s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeLength = 275;
+const int s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeLength = 274;
 static const JSC::Intrinsic s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCode = "(function (d,g){\"use strict\";const _=@newPromiseCapability(@Promise);return @getByIdDirectPrivate(d,\"transformAlgorithm\").@call(@undefined,g).@then(()=>{_.@resolve()},(f)=>{@transformStreamError(@getByIdDirectPrivate(d,\"stream\"),f),_.reject.@call(@undefined,f)}),_.promise})\n";
+const char* const s_transformStreamInternalsTransformStreamDefaultControllerPerformTransformCode = "(function (d,g){\"use strict\";const _=@newPromiseCapability(@Promise);return @getByIdDirectPrivate(d,\"transformAlgorithm\").@call(@undefined,g).@then(()=>{_.resolve()},(f)=>{@transformStreamError(@getByIdDirectPrivate(d,\"stream\"),f),_.reject.@call(@undefined,f)}),_.promise})\n";
 
 // transformStreamDefaultControllerTerminate
 const JSC::ConstructAbility s_transformStreamInternalsTransformStreamDefaultControllerTerminateCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
@@ -596,9 +596,9 @@ const char* const s_transformStreamInternalsTransformStreamDefaultControllerTerm
 const JSC::ConstructAbility s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeLength = 759;
+const int s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeLength = 758;
 static const JSC::Intrinsic s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCode = "(function (d,q){\"use strict\";const j=@getByIdDirectPrivate(d,\"internalWritable\");@assert(@getByIdDirectPrivate(j,\"state\")===\"writable\");const v=@getByIdDirectPrivate(d,\"controller\");if(@getByIdDirectPrivate(d,\"backpressure\")){const _=@newPromiseCapability(@Promise),x=@getByIdDirectPrivate(d,\"backpressureChangePromise\");return @assert(x!==@undefined),x.promise.@then(()=>{const f=@getByIdDirectPrivate(j,\"state\");if(f===\"erroring\"){_.reject.@call(@undefined,@getByIdDirectPrivate(j,\"storedError\"));return}@assert(f===\"writable\"),@transformStreamDefaultControllerPerformTransform(v,q).@then(()=>{_.@resolve()},(z)=>{_.reject.@call(@undefined,z)})},(f)=>{_.reject.@call(@undefined,f)}),_.promise}return @transformStreamDefaultControllerPerformTransform(v,q)})\n";
+const char* const s_transformStreamInternalsTransformStreamDefaultSinkWriteAlgorithmCode = "(function (d,q){\"use strict\";const j=@getByIdDirectPrivate(d,\"internalWritable\");@assert(@getByIdDirectPrivate(j,\"state\")===\"writable\");const v=@getByIdDirectPrivate(d,\"controller\");if(@getByIdDirectPrivate(d,\"backpressure\")){const _=@newPromiseCapability(@Promise),x=@getByIdDirectPrivate(d,\"backpressureChangePromise\");return @assert(x!==@undefined),x.promise.@then(()=>{const f=@getByIdDirectPrivate(j,\"state\");if(f===\"erroring\"){_.reject.@call(@undefined,@getByIdDirectPrivate(j,\"storedError\"));return}@assert(f===\"writable\"),@transformStreamDefaultControllerPerformTransform(v,q).@then(()=>{_.resolve()},(z)=>{_.reject.@call(@undefined,z)})},(f)=>{_.reject.@call(@undefined,f)}),_.promise}return @transformStreamDefaultControllerPerformTransform(v,q)})\n";
 
 // transformStreamDefaultSinkAbortAlgorithm
 const JSC::ConstructAbility s_transformStreamInternalsTransformStreamDefaultSinkAbortAlgorithmCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
@@ -612,9 +612,9 @@ const char* const s_transformStreamInternalsTransformStreamDefaultSinkAbortAlgor
 const JSC::ConstructAbility s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeLength = 786;
+const int s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeLength = 785;
 static const JSC::Intrinsic s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCode = "(function (j){\"use strict\";const _=@getByIdDirectPrivate(j,\"readable\"),I=@getByIdDirectPrivate(j,\"controller\"),k=@getByIdDirectPrivate(_,\"readableStreamController\"),q=@getByIdDirectPrivate(I,\"flushAlgorithm\");@assert(q!==@undefined);const u=@getByIdDirectPrivate(I,\"flushAlgorithm\").@call();@transformStreamDefaultControllerClearAlgorithms(I);const S=@newPromiseCapability(@Promise);return u.@then(()=>{if(@getByIdDirectPrivate(_,\"state\")===@streamErrored){S.reject.@call(@undefined,@getByIdDirectPrivate(_,\"storedError\"));return}if(@readableStreamDefaultControllerCanCloseOrEnqueue(k))@readableStreamDefaultControllerClose(k);S.@resolve()},(v)=>{@transformStreamError(@getByIdDirectPrivate(I,\"stream\"),v),S.reject.@call(@undefined,@getByIdDirectPrivate(_,\"storedError\"))}),S.promise})\n";
+const char* const s_transformStreamInternalsTransformStreamDefaultSinkCloseAlgorithmCode = "(function (S){\"use strict\";const _=@getByIdDirectPrivate(S,\"readable\"),u=@getByIdDirectPrivate(S,\"controller\"),c=@getByIdDirectPrivate(_,\"readableStreamController\"),g=@getByIdDirectPrivate(u,\"flushAlgorithm\");@assert(g!==@undefined);const j=@getByIdDirectPrivate(u,\"flushAlgorithm\").@call();@transformStreamDefaultControllerClearAlgorithms(u);const I=@newPromiseCapability(@Promise);return j.@then(()=>{if(@getByIdDirectPrivate(_,\"state\")===@streamErrored){I.reject.@call(@undefined,@getByIdDirectPrivate(_,\"storedError\"));return}if(@readableStreamDefaultControllerCanCloseOrEnqueue(c))@readableStreamDefaultControllerClose(c);I.resolve()},(k)=>{@transformStreamError(@getByIdDirectPrivate(u,\"stream\"),k),I.reject.@call(@undefined,@getByIdDirectPrivate(_,\"storedError\"))}),I.promise})\n";
 
 // transformStreamDefaultSourcePullAlgorithm
 const JSC::ConstructAbility s_transformStreamInternalsTransformStreamDefaultSourcePullAlgorithmCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
@@ -1506,33 +1506,33 @@ const char* const s_readableStreamInternalsPipeToFinalizeCode = "(function (l){\
 const JSC::ConstructAbility s_readableStreamInternalsReadableStreamTeeCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInternalsReadableStreamTeeCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_readableStreamInternalsReadableStreamTeeCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_readableStreamInternalsReadableStreamTeeCodeLength = 1102;
+const int s_readableStreamInternalsReadableStreamTeeCodeLength = 1067;
 static const JSC::Intrinsic s_readableStreamInternalsReadableStreamTeeCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_readableStreamInternalsReadableStreamTeeCode = "(function (i,q){\"use strict\";@assert(@isReadableStream(i)),@assert(typeof q===\"boolean\");var v=@getByIdDirectPrivate(i,\"start\");if(v)@putByIdDirectPrivate(i,\"start\",@undefined),v();const w=new @ReadableStreamDefaultReader(i),_={closedOrErrored:!1,canceled1:!1,canceled2:!1,reason1:@undefined,reason2:@undefined};_.cancelPromiseCapability=@newPromiseCapability(@Promise);const x=@readableStreamTeePullFunction(_,w,q),f={};@putByIdDirectPrivate(f,\"pull\",x),@putByIdDirectPrivate(f,\"cancel\",@readableStreamTeeBranch1CancelFunction(_,i));const g={};@putByIdDirectPrivate(g,\"pull\",x),@putByIdDirectPrivate(g,\"cancel\",@readableStreamTeeBranch2CancelFunction(_,i));const j=new @ReadableStream(f),k=new @ReadableStream(g);return @getByIdDirectPrivate(w,\"closedPromiseCapability\").promise.@then(@undefined,function(y){if(_.closedOrErrored)return;if(@readableStreamDefaultControllerError(j.@readableStreamController,y),@readableStreamDefaultControllerError(k.@readableStreamController,y),_.closedOrErrored=!0,!_.canceled1||!_.canceled2)_.cancelPromiseCapability.resolve.@call()}),_.branch1=j,_.branch2=k,[j,k]})\n";
+const char* const s_readableStreamInternalsReadableStreamTeeCode = "(function (f,k){\"use strict\";@assert(@isReadableStream(f)),@assert(typeof k===\"boolean\");var q=@getByIdDirectPrivate(f,\"start\");if(q)@putByIdDirectPrivate(f,\"start\",@undefined),q();const v=new @ReadableStreamDefaultReader(f),i={stream:f,canceled1:!1,canceled2:!1,reason1:@undefined,reason2:@undefined,reading:!1,readAgain:!1};i.cancelPromiseCapability=@newPromiseCapability(@Promise);const w=@readableStreamTeePullFunction(i,v,k),_={};@putByIdDirectPrivate(_,\"pull\",w),@putByIdDirectPrivate(_,\"cancel\",@readableStreamTeeBranch1CancelFunction(i,f));const D={};@putByIdDirectPrivate(D,\"pull\",w),@putByIdDirectPrivate(D,\"cancel\",@readableStreamTeeBranch2CancelFunction(i,f));const g=new @ReadableStream(_),j=new @ReadableStream(D);return @getByIdDirectPrivate(v,\"closedPromiseCapability\").promise.@then(@undefined,function(x){if(@readableStreamDefaultControllerError(g.@readableStreamController,x),@readableStreamDefaultControllerError(j.@readableStreamController,x),!i.canceled1||!i.canceled2)i.cancelPromiseCapability.resolve.@call()}),i.branch1=g,i.branch2=j,[g,j]})\n";
 
 // readableStreamTeePullFunction
 const JSC::ConstructAbility s_readableStreamInternalsReadableStreamTeePullFunctionCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInternalsReadableStreamTeePullFunctionCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_readableStreamInternalsReadableStreamTeePullFunctionCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_readableStreamInternalsReadableStreamTeePullFunctionCodeLength = 763;
+const int s_readableStreamInternalsReadableStreamTeePullFunctionCodeLength = 1235;
 static const JSC::Intrinsic s_readableStreamInternalsReadableStreamTeePullFunctionCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_readableStreamInternalsReadableStreamTeePullFunctionCode = "(function (_,c,f){\"use strict\";return function(){@Promise.prototype.@then.@call(@readableStreamDefaultReaderRead(c),function(i){if(@assert(@isObject(i)),@assert(typeof i.done===\"boolean\"),i.done&&!_.closedOrErrored){if(!_.canceled1)@readableStreamDefaultControllerClose(_.branch1.@readableStreamController);if(!_.canceled2)@readableStreamDefaultControllerClose(_.branch2.@readableStreamController);if(_.closedOrErrored=!0,!_.canceled1||!_.canceled2)_.cancelPromiseCapability.resolve.@call()}if(_.closedOrErrored)return;if(!_.canceled1)@readableStreamDefaultControllerEnqueue(_.branch1.@readableStreamController,i.value);if(!_.canceled2)@readableStreamDefaultControllerEnqueue(_.branch2.@readableStreamController,f\?@structuredCloneForStream(i.value):i.value)})}})\n";
+const char* const s_readableStreamInternalsReadableStreamTeePullFunctionCode = "(function (_,q,v){\"use strict\";var d=function(){if(_.reading)return _.readAgain=!0,@Promise.resolve();return _.reading=!0,@Promise.prototype.@then.@call(@readableStreamDefaultReaderRead(q),function(b){if(@assert(@isObject(b)),@assert(typeof b.done===\"boolean\"),b.done){if(_.reading=!1,!_.canceled1)@readableStreamDefaultControllerClose(_.branch1.@readableStreamController);if(!_.canceled2)@readableStreamDefaultControllerClose(_.branch2.@readableStreamController);if(!_.canceled1||!_.canceled2)_.cancelPromiseCapability.resolve.@call();return}_.readAgain=!1;let f=b.value,j=f;if(!_.canceled2&&v&&typeof f!==\"string\")try{j=@structuredCloneForStream(f)}catch(i){@readableStreamDefaultControllerError(_.branch1.@readableStreamController,i),@readableStreamDefaultControllerError(_.branch2.@readableStreamController,i),@readableStreamCancel(_.stream,i).@then(_.cancelPromiseCapability.resolve,_.cancelPromiseCapability.reject);return}if(!_.canceled1)@readableStreamDefaultControllerEnqueue(_.branch1.@readableStreamController,f);if(!_.canceled2)@readableStreamDefaultControllerEnqueue(_.branch2.@readableStreamController,j);_.reading=!1,@Promise.resolve().@then(()=>{if(_.readAgain)d()})},()=>{_.reading=!1}),@Promise.resolve()};return d})\n";
 
 // readableStreamTeeBranch1CancelFunction
 const JSC::ConstructAbility s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeLength = 257;
+const int s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeLength = 255;
 static const JSC::Intrinsic s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCode = "(function (d,i){\"use strict\";return function(n){if(d.canceled1=!0,d.reason1=n,d.canceled2)@readableStreamCancel(i,[d.reason1,d.reason2]).@then(d.cancelPromiseCapability.@resolve,d.cancelPromiseCapability.@reject);return d.cancelPromiseCapability.promise}})\n";
+const char* const s_readableStreamInternalsReadableStreamTeeBranch1CancelFunctionCode = "(function (c,d){\"use strict\";return function(n){if(c.canceled1=!0,c.reason1=n,c.canceled2)@readableStreamCancel(d,[c.reason1,c.reason2]).@then(c.cancelPromiseCapability.resolve,c.cancelPromiseCapability.reject);return c.cancelPromiseCapability.promise}})\n";
 
 // readableStreamTeeBranch2CancelFunction
 const JSC::ConstructAbility s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
 const JSC::ConstructorKind s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeConstructorKind = JSC::ConstructorKind::None;
 const JSC::ImplementationVisibility s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
-const int s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeLength = 257;
+const int s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeLength = 255;
 static const JSC::Intrinsic s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCodeIntrinsic = JSC::NoIntrinsic;
-const char* const s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCode = "(function (d,i){\"use strict\";return function(n){if(d.canceled2=!0,d.reason2=n,d.canceled1)@readableStreamCancel(i,[d.reason1,d.reason2]).@then(d.cancelPromiseCapability.@resolve,d.cancelPromiseCapability.@reject);return d.cancelPromiseCapability.promise}})\n";
+const char* const s_readableStreamInternalsReadableStreamTeeBranch2CancelFunctionCode = "(function (c,d){\"use strict\";return function(n){if(c.canceled2=!0,c.reason2=n,c.canceled1)@readableStreamCancel(d,[c.reason1,c.reason2]).@then(c.cancelPromiseCapability.resolve,c.cancelPromiseCapability.reject);return c.cancelPromiseCapability.promise}})\n";
 
 // isReadableStream
 const JSC::ConstructAbility s_readableStreamInternalsIsReadableStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;