From fb6e6054086f903a570bd4ec73729b18c1ec870c Mon Sep 17 00:00:00 2001
From: Matteo Collina <hello@matteocollina.com>
Date: Mon, 29 Jun 2026 10:31:16 +0200
Subject: [PATCH] stream: expose ReadableStreamTee

Signed-off-by: Matteo Collina <hello@matteocollina.com>
---
 doc/api/webstreams.md                       | 20 ++++++++++++++++++
 lib/stream/web.js                           | 21 +++++++++++++++++++
 test/parallel/test-whatwg-readablestream.js | 23 +++++++++++++++++++++
 3 files changed, 64 insertions(+)

diff --git a/doc/api/webstreams.md b/doc/api/webstreams.md
index 55b27584361e1c..5108c80d4303cf 100644
--- a/doc/api/webstreams.md
+++ b/doc/api/webstreams.md
@@ -106,6 +106,26 @@ For more details refer to the relevant documentation:
 
 ## API
 
+### `ReadableStreamTee(stream[, cloneForBranch2])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `stream` {ReadableStream}
+* `cloneForBranch2` {boolean} When `true`, chunks enqueued into the second
+  branch are cloned from chunks enqueued into the first branch. **Default:**
+  `false`.
+* Returns: {ReadableStream\[]} Two {ReadableStream} branches.
+
+Runs the WHATWG `ReadableStreamTee` abstract operation on `stream`.
+
+This differs from `readableStream.tee()` only when `cloneForBranch2` is
+`true`. The `tee()` method always passes `false`, while other web platform
+specifications, such as Fetch body cloning, pass `true` so that the second
+branch receives cloned chunks and consumption of one branch cannot mutate chunks
+seen by the other.
+
 ### Class: `ReadableStream`
 
 <!-- YAML
diff --git a/lib/stream/web.js b/lib/stream/web.js
index 8278040f690cd0..cc417c62f5d0de 100644
--- a/lib/stream/web.js
+++ b/lib/stream/web.js
@@ -18,8 +18,20 @@ const {
   ReadableStreamBYOBRequest,
   ReadableByteStreamController,
   ReadableStreamDefaultController,
+  isReadableStream,
+  readableStreamTee,
 } = require('internal/webstreams/readablestream');
 
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+  },
+} = require('internal/errors');
+
+const {
+  validateBoolean,
+} = require('internal/validators');
+
 const {
   ByteLengthQueuingStrategy,
   CountQueuingStrategy,
@@ -35,8 +47,17 @@ const {
   DecompressionStream,
 } = require('internal/webstreams/compression');
 
+function ReadableStreamTee(stream, cloneForBranch2 = false) {
+  if (!isReadableStream(stream)) {
+    throw new ERR_INVALID_ARG_TYPE('stream', 'ReadableStream', stream);
+  }
+  validateBoolean(cloneForBranch2, 'cloneForBranch2');
+  return readableStreamTee(stream, cloneForBranch2);
+}
+
 module.exports = {
   ReadableStream,
+  ReadableStreamTee,
   ReadableStreamDefaultReader,
   ReadableStreamBYOBReader,
   ReadableStreamBYOBRequest,
diff --git a/test/parallel/test-whatwg-readablestream.js b/test/parallel/test-whatwg-readablestream.js
index 2fd99d33929023..d1001d51b4e8d1 100644
--- a/test/parallel/test-whatwg-readablestream.js
+++ b/test/parallel/test-whatwg-readablestream.js
@@ -15,6 +15,7 @@ const {
   ByteLengthQueuingStrategy,
   CountQueuingStrategy,
   ReadableStream,
+  ReadableStreamTee,
   ReadableStreamDefaultReader,
   ReadableStreamDefaultController,
   ReadableByteStreamController,
@@ -1527,6 +1528,28 @@ class Source {
   }).then(common.mustCall());
 }
 
+{
+  // Test public ReadableStreamTee() cloneForBranch2 argument
+  assert.strictEqual(typeof ReadableStreamTee, 'function');
+  const chunk = new Uint8Array([65]);
+  const readable = new ReadableStream({
+    start(controller) {
+      controller.enqueue(chunk);
+      controller.close();
+    },
+  });
+  const [r1, r2] = ReadableStreamTee(readable, true);
+
+  (async () => {
+    const { value: value1 } = await r1.getReader().read();
+    assert.strictEqual(value1[0], 65);
+    value1[0] = 66;
+
+    const { value: value2 } = await r2.getReader().read();
+    assert.strictEqual(value2[0], 65);
+  })().then(common.mustCall());
+}
+
 {
   // Test tee() cloneForBranch2 argument
   const readable = new ReadableStream({