@@ -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;
+  }
+}
@@ -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) {
 
@@ -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;
 }
 
 
@@ -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) {