stream: unify internal webstream construction

Streams created internally (transform stream sides, tee branches,
ReadableStream.from, transferred streams) were built by wrapper
constructors that swapped the prototype of every instance and then
assigned an own, enumerable `constructor` property to look like a public
stream. Each internal stream therefore had its own hidden class and
`Object.keys(stream)` reported `['constructor']`.

The public constructors now accept the internal construction sentinel
and leave controller setup to the caller, so every ReadableStream and
WritableStream shares one hidden class and no per-instance prototype
swap or own property is needed.

Signed-off-by: Matteo Collina <hello@matteocollina.com>

Author: mcollina

lib/internal/webstreams/readablestream.js

@@ -253,6 +253,13 @@ class ReadableStream {
    */
   constructor(source = kEmptyObject, strategy = kEmptyObject) {
     markTransferMode(this, false, true);
+    // Internal construction (tee, transform streams, adapters, transfer):
+    // the caller sets up the controller, so every ReadableStream shares
+    // one hidden class and no per-instance prototype swap is needed.
+    if (source === kSkipThrow) {
+      this[kState] = createReadableStreamState();
+      return;
+    }
     validateObject(source, 'source', kValidateObjectAllowObjects);
     validateObject(strategy, 'strategy', kValidateObjectAllowObjectsAndNull);
     this[kState] = createReadableStreamState();
@@ -718,22 +725,8 @@ ObjectDefineProperties(ReadableStream, {
   from: kEnumerableProperty,
 });
 
-function InternalTransferredReadableStream() {
-  ObjectSetPrototypeOf(this, ReadableStream.prototype);
-  markTransferMode(this, false, true);
-  this[kType] = 'ReadableStream';
-  this[kState] = createReadableStreamState();
-}
-
-ObjectSetPrototypeOf(InternalTransferredReadableStream.prototype, ReadableStream.prototype);
-ObjectSetPrototypeOf(InternalTransferredReadableStream, ReadableStream);
-
 function TransferredReadableStream() {
-  const stream = new InternalTransferredReadableStream();
-
-  stream.constructor = ReadableStream;
-
-  return stream;
+  return new ReadableStream(kSkipThrow);
 }
 
 TransferredReadableStream.prototype[kDeserialize] = () => {};
@@ -1350,57 +1343,29 @@ ObjectDefineProperties(ReadableByteStreamController.prototype, {
   [SymbolToStringTag]: getNonWritablePropertyDescriptor(ReadableByteStreamController.name),
 });
 
-function InternalReadableStream(start, pull, cancel, highWaterMark, size) {
-  ObjectSetPrototypeOf(this, ReadableStream.prototype);
-  markTransferMode(this, false, true);
-  this[kType] = 'ReadableStream';
-  this[kState] = createReadableStreamState();
-  const controller = new ReadableStreamDefaultController(kSkipThrow);
+function createReadableStream(start, pull, cancel, highWaterMark = 1, size = defaultSizeAlgorithm) {
+  const stream = new ReadableStream(kSkipThrow);
   setupReadableStreamDefaultController(
-    this,
-    controller,
+    stream,
+    new ReadableStreamDefaultController(kSkipThrow),
     start,
     pull,
     cancel,
     highWaterMark,
     size);
-}
-
-ObjectSetPrototypeOf(InternalReadableStream.prototype, ReadableStream.prototype);
-ObjectSetPrototypeOf(InternalReadableStream, ReadableStream);
-
-function createReadableStream(start, pull, cancel, highWaterMark = 1, size = defaultSizeAlgorithm) {
-  const stream = new InternalReadableStream(start, pull, cancel, highWaterMark, size);
-
-  // For spec compliance the InternalReadableStream must be a ReadableStream
-  stream.constructor = ReadableStream;
   return stream;
 }
 
-function InternalReadableByteStream(start, pull, cancel) {
-  ObjectSetPrototypeOf(this, ReadableStream.prototype);
-  markTransferMode(this, false, true);
-  this[kType] = 'ReadableStream';
-  this[kState] = createReadableStreamState();
-  const controller = new ReadableByteStreamController(kSkipThrow);
+function createReadableByteStream(start, pull, cancel) {
+  const stream = new ReadableStream(kSkipThrow);
   setupReadableByteStreamController(
-    this,
-    controller,
+    stream,
+    new ReadableByteStreamController(kSkipThrow),
     start,
     pull,
     cancel,
     0,
     undefined);
-}
-
-ObjectSetPrototypeOf(InternalReadableByteStream.prototype, ReadableStream.prototype);
-ObjectSetPrototypeOf(InternalReadableByteStream, ReadableStream);
-
-function createReadableByteStream(start, pull, cancel) {
-  const stream = new InternalReadableByteStream(start, pull, cancel);
-
-  // For spec compliance the InternalReadableByteStream must be a ReadableStream
-  stream.constructor = ReadableStream;
   return stream;
 }
 

lib/internal/webstreams/writablestream.js

@@ -183,6 +183,13 @@ class WritableStream {
    */
   constructor(sink = kEmptyObject, strategy = kEmptyObject) {
     markTransferMode(this, false, true);
+    // Internal construction (transform streams, adapters, transfer):
+    // the caller sets up the controller, so every WritableStream shares
+    // one hidden class and no per-instance prototype swap is needed.
+    if (sink === kSkipThrow) {
+      this[kState] = createWritableStreamState();
+      return;
+    }
     validateObject(sink, 'sink', kValidateObjectAllowObjects);
     validateObject(strategy, 'strategy', kValidateObjectAllowObjectsAndNull);
     const type = sink?.type;
@@ -351,22 +358,8 @@ ObjectDefineProperties(WritableStream.prototype, {
   [SymbolToStringTag]: getNonWritablePropertyDescriptor(WritableStream.name),
 });
 
-function InternalTransferredWritableStream() {
-  ObjectSetPrototypeOf(this, WritableStream.prototype);
-  markTransferMode(this, false, true);
-  this[kType] = 'WritableStream';
-  this[kState] = createWritableStreamState();
-}
-
-ObjectSetPrototypeOf(InternalTransferredWritableStream.prototype, WritableStream.prototype);
-ObjectSetPrototypeOf(InternalTransferredWritableStream, WritableStream);
-
 function TransferredWritableStream() {
-  const stream = new InternalTransferredWritableStream();
-
-  stream.constructor = WritableStream;
-
-  return stream;
+  return new WritableStream(kSkipThrow);
 }
 
 TransferredWritableStream.prototype[kDeserialize] = () => {};
@@ -559,33 +552,18 @@ ObjectDefineProperties(WritableStreamDefaultController.prototype, {
   [SymbolToStringTag]: getNonWritablePropertyDescriptor(WritableStreamDefaultController.name),
 });
 
-function InternalWritableStream(start, write, close, abort, highWaterMark, size) {
-  ObjectSetPrototypeOf(this, WritableStream.prototype);
-  markTransferMode(this, false, true);
-  this[kType] = 'WritableStream';
-  this[kState] = createWritableStreamState();
-
-  const controller = new WritableStreamDefaultController(kSkipThrow);
+function createWritableStream(start, write, close, abort, highWaterMark = 1, size = defaultSizeAlgorithm) {
+  const stream = new WritableStream(kSkipThrow);
   setupWritableStreamDefaultController(
-    this,
-    controller,
+    stream,
+    new WritableStreamDefaultController(kSkipThrow),
     start,
     write,
     close,
     abort,
     highWaterMark,
     size,
   );
-}
-
-ObjectSetPrototypeOf(InternalWritableStream.prototype, WritableStream.prototype);
-ObjectSetPrototypeOf(InternalWritableStream, WritableStream);
-
-function createWritableStream(start, write, close, abort, highWaterMark = 1, size = defaultSizeAlgorithm) {
-  const stream = new InternalWritableStream(start, write, close, abort, highWaterMark, size);
-
-  // For spec compliance the InternalWritableStream must be a WritableStream
-  stream.constructor = WritableStream;
   return stream;
 }
 

test/parallel/test-whatwg-webstreams-internal-construction.js

@@ -0,0 +1,53 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const {
+  ReadableStream,
+  WritableStream,
+  TransformStream,
+} = require('stream/web');
+
+// Streams created by internal code paths (transform stream sides, tee
+// branches, ReadableStream.from, transferred streams) are plain
+// ReadableStream/WritableStream instances: same prototype and no own
+// properties beyond what the public constructors create.
+
+function check(stream, Class) {
+  assert.ok(stream instanceof Class);
+  assert.strictEqual(Object.getPrototypeOf(stream), Class.prototype);
+  assert.strictEqual(stream.constructor, Class);
+  assert.deepStrictEqual(Object.keys(stream), Object.keys(new Class()));
+  assert.strictEqual(
+    Object.getOwnPropertyDescriptor(stream, 'constructor'), undefined);
+}
+
+{
+  const { readable, writable } = new TransformStream();
+  check(readable, ReadableStream);
+  check(writable, WritableStream);
+}
+
+{
+  const [branch1, branch2] = new ReadableStream().tee();
+  check(branch1, ReadableStream);
+  check(branch2, ReadableStream);
+}
+
+{
+  const [branch1, branch2] = new ReadableStream({ type: 'bytes' }).tee();
+  check(branch1, ReadableStream);
+  check(branch2, ReadableStream);
+}
+
+check(ReadableStream.from([]), ReadableStream);
+
+{
+  const readable = new ReadableStream();
+  const writable = new WritableStream();
+  const transferred = structuredClone(
+    { readable, writable },
+    { transfer: [readable, writable] });
+  check(transferred.readable, ReadableStream);
+  check(transferred.writable, WritableStream);
+}