stream: keep webstream stream states in fast-mode objects

The per-stream state records were built as object literals with
__proto__: null, which V8 creates as dictionary-mode objects: roughly
50x slower to allocate, and every subsequent property load on them is a
dictionary lookup. These records back every hot path, so both stream
construction and per-chunk field accesses were paying for it.

Replace the literals with classes whose prototype has a null prototype,
so instances stay in fast mode while Object.prototype remains excluded
from the lookup chain. Every field ever assigned is declared up front
so the shape never transitions.

Also add benchmark/webstreams/lifecycle.js covering the short-lived
stream pattern (create, few chunks, close) that first exposed this.

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

Author: mcollina

benchmark/webstreams/lifecycle.js

@@ -0,0 +1,76 @@
+'use strict';
+const common = require('../common.js');
+const assert = require('assert');
+const {
+  ReadableStream,
+  WritableStream,
+  TransformStream,
+} = require('node:stream/web');
+
+const bench = common.createBenchmark(main, {
+  n: [5e4],
+  kind: ['readable', 'pipe-to', 'pipe-through'],
+});
+
+const chunk = Buffer.alloc(1024);
+
+function makeSource() {
+  let i = 0;
+  return {
+    pull(controller) {
+      if (i++ < 4)
+        controller.enqueue(chunk);
+      else
+        controller.close();
+    },
+  };
+}
+
+async function readable(n) {
+  let chunks = 0;
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const reader = new ReadableStream(makeSource()).getReader();
+    while (!(await reader.read()).done) chunks++;
+  }
+  bench.end(n);
+  assert.strictEqual(chunks, n * 4);
+}
+
+async function pipeTo(n) {
+  let chunks = 0;
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    await new ReadableStream(makeSource())
+      .pipeTo(new WritableStream({ write() { chunks++; } }));
+  }
+  bench.end(n);
+  assert.strictEqual(chunks, n * 4);
+}
+
+async function pipeThrough(n) {
+  let chunks = 0;
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const reader = new ReadableStream(makeSource())
+      .pipeThrough(new TransformStream())
+      .getReader();
+    while (!(await reader.read()).done) chunks++;
+  }
+  bench.end(n);
+  assert.strictEqual(chunks, n * 4);
+}
+
+function main({ n, kind }) {
+  switch (kind) {
+    case 'readable':
+      readable(n);
+      break;
+    case 'pipe-to':
+      pipeTo(n);
+      break;
+    case 'pipe-through':
+      pipeThrough(n);
+      break;
+  }
+}

lib/internal/webstreams/readablestream.js

@@ -1419,22 +1419,30 @@ const isReadableStreamBYOBReader =
 
 // ---- ReadableStream Implementation
 
+// The state record classes null out their prototype chain to keep
+// Object.prototype out of property lookups; every field ever assigned
+// is declared so the shape never transitions.
+class ReadableStreamTransferState {
+  writable = undefined;
+  port1 = undefined;
+  port2 = undefined;
+  promise = undefined;
+}
+ObjectSetPrototypeOf(ReadableStreamTransferState.prototype, null);
+
+class ReadableStreamState {
+  closedPromise = undefined;
+  disturbed = false;
+  reader = undefined;
+  state = 'readable';
+  storedError = undefined;
+  controller = undefined;
+  transfer = new ReadableStreamTransferState();
+}
+ObjectSetPrototypeOf(ReadableStreamState.prototype, null);
+
 function createReadableStreamState() {
-  return {
-    __proto__: null,
-    closedPromise: undefined,
-    disturbed: false,
-    reader: undefined,
-    state: 'readable',
-    storedError: undefined,
-    transfer: {
-      __proto__: null,
-      writable: undefined,
-      port1: undefined,
-      port2: undefined,
-      promise: undefined,
-    },
-  };
+  return new ReadableStreamState();
 }
 
 function readableStreamFromIterable(iterable) {

lib/internal/webstreams/transformstream.js

@@ -253,21 +253,38 @@ ObjectDefineProperties(TransformStream.prototype, {
   [SymbolToStringTag]: getNonWritablePropertyDescriptor(TransformStream.name),
 });
 
+// The state record classes null out their prototype chain to keep
+// Object.prototype out of property lookups; every field ever assigned
+// is declared so the shape never transitions.
+class TransformStreamState {
+  readable = undefined;
+  writable = undefined;
+  controller = undefined;
+  backpressure = undefined;
+  // Continuation slots replacing the spec's
+  // [[backpressureChangePromise]]; see transformStreamSetBackpressure.
+  pullPending = false;
+  pendingWrite = undefined;
+  pendingWriteChunk = undefined;
+  writeContinuation = undefined;
+}
+ObjectSetPrototypeOf(TransformStreamState.prototype, null);
+
+class TransformStreamControllerState {
+  stream = undefined;
+  transformAlgorithm = undefined;
+  flushAlgorithm = undefined;
+  cancelAlgorithm = undefined;
+  performTransformRejected = undefined;
+  finishPromise = undefined;
+}
+ObjectSetPrototypeOf(TransformStreamControllerState.prototype, null);
+
 function InternalTransferredTransformStream() {
   ObjectSetPrototypeOf(this, TransformStream.prototype);
   markTransferMode(this, false, true);
   this[kType] = 'TransformStream';
-  this[kState] = {
-    __proto__: null,
-    readable: undefined,
-    writable: undefined,
-    backpressure: undefined,
-    pullPending: false,
-    pendingWrite: undefined,
-    pendingWriteChunk: undefined,
-    writeContinuation: undefined,
-    controller: undefined,
-  };
+  this[kState] = new TransformStreamState();
 }
 
 ObjectSetPrototypeOf(InternalTransferredTransformStream.prototype, TransformStream.prototype);
@@ -388,19 +405,10 @@ function initializeTransformStream(
     readableSizeAlgorithm,
   );
 
-  stream[kState] = {
-    __proto__: null,
-    readable,
-    writable,
-    controller: undefined,
-    backpressure: undefined,
-    // Continuation slots replacing the spec's
-    // [[backpressureChangePromise]]; see transformStreamSetBackpressure.
-    pullPending: false,
-    pendingWrite: undefined,
-    pendingWriteChunk: undefined,
-    writeContinuation: undefined,
-  };
+  const state = new TransformStreamState();
+  state.readable = readable;
+  state.writable = writable;
+  stream[kState] = state;
 
   transformStreamSetBackpressure(stream, true);
 }
@@ -470,14 +478,12 @@ function setupTransformStreamDefaultController(
   cancelAlgorithm) {
   assert(isTransformStream(stream));
   assert(stream[kState].controller === undefined);
-  controller[kState] = {
-    __proto__: null,
-    stream,
-    transformAlgorithm,
-    flushAlgorithm,
-    cancelAlgorithm,
-    performTransformRejected: undefined,
-  };
+  const controllerState = new TransformStreamControllerState();
+  controllerState.stream = stream;
+  controllerState.transformAlgorithm = transformAlgorithm;
+  controllerState.flushAlgorithm = flushAlgorithm;
+  controllerState.cancelAlgorithm = cancelAlgorithm;
+  controller[kState] = controllerState;
   stream[kState].controller = controller;
 }
 

lib/internal/webstreams/writablestream.js

@@ -596,35 +596,42 @@ const isWritableStreamDefaultWriter =
 const isWritableStreamDefaultController =
   isBrandCheck('WritableStreamDefaultController');
 
+// The state record classes null out their prototype chain to keep
+// Object.prototype out of property lookups; every field ever assigned
+// is declared so the shape never transitions.
+class WritableStreamTransferState {
+  readable = undefined;
+  port1 = undefined;
+  port2 = undefined;
+  promise = undefined;
+}
+ObjectSetPrototypeOf(WritableStreamTransferState.prototype, null);
+
+class WritableStreamState {
+  closedPromise = undefined;
+  closeRequest = kNilRequest;
+  // Mirrors "closeRequest or inFlightCloseRequest is pending"; kept as a
+  // flag because the predicate runs several times per chunk on the write
+  // hot path.
+  closeQueuedOrInFlight = false;
+  inFlightWriteRequest = kNilRequest;
+  inFlightCloseRequest = kNilRequest;
+  pendingAbortRequest = kNilPendingAbortRequest;
+  backpressure = false;
+  controller = undefined;
+  state = 'writable';
+  storedError = undefined;
+  // Ring-buffer request queue, materialized lazily on the first pending
+  // write (see writableStreamAddWriteRequest) so construction allocates
+  // no request storage.
+  writeRequests = kEmptyQueue;
+  writer = undefined;
+  transfer = new WritableStreamTransferState();
+}
+ObjectSetPrototypeOf(WritableStreamState.prototype, null);
+
 function createWritableStreamState() {
-  return {
-    __proto__: null,
-    closedPromise: undefined,
-    closeRequest: kNilRequest,
-    // Mirrors "closeRequest or inFlightCloseRequest is pending"; kept as a
-    // flag because the predicate runs several times per chunk on the write
-    // hot path.
-    closeQueuedOrInFlight: false,
-    inFlightWriteRequest: kNilRequest,
-    inFlightCloseRequest: kNilRequest,
-    pendingAbortRequest: kNilPendingAbortRequest,
-    backpressure: false,
-    controller: undefined,
-    state: 'writable',
-    storedError: undefined,
-    // Ring-buffer request queue, materialized lazily on the first pending
-    // write (see writableStreamAddWriteRequest) so construction allocates
-    // no request storage.
-    writeRequests: kEmptyQueue,
-    writer: undefined,
-    transfer: {
-      __proto__: null,
-      readable: undefined,
-      port1: undefined,
-      port2: undefined,
-      promise: undefined,
-    },
-  };
+  return new WritableStreamState();
 }
 
 function isWritableStreamLocked(stream) {