src,lib: format and lint the webstreams engine

clang-format over src/streams (clearing 42 of the 45 cpplint findings;
the remaining three were util.h/util-inl.h double includes) and a full
eslint pass over lib/internal/webstreams: ReflectApply with
array-literal arguments becomes FunctionPrototypeCall, read-result
literals go done-first, tee branches and from()'s stream become const,
JSDoc @returns added to the public constructors, non-ASCII punctuation
swept from comments, and unused/missing primordials imports fixed.
Zero eslint and cpplint findings remain in the flipped files.

No behavior change intended. WPT streams 1404 (plain and
--stress-incremental-marking), compression plus x3 stress, encoding,
and the parallel whatwg/webstream suites green; readable-read official
rows and the byte/transform spot shapes re-measured unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: mcollina

lib/internal/webstreams/readablestream.js

@@ -5,6 +5,7 @@ const {
   PromiseResolve,
   PromiseWithResolvers,
   ReflectConstruct,
+  Symbol,
 } = primordials;
 
 const {

lib/internal/webstreams/transfer.js

@@ -1,13 +1,12 @@
 'use strict';
 
 const {
+  FunctionPrototypeCall,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectGetOwnPropertyDescriptor,
   ObjectPrototypeIsPrototypeOf,
   ObjectSetPrototypeOf,
-  ReflectApply,
-  Symbol,
   SymbolToStringTag,
 } = primordials;
 
@@ -64,8 +63,8 @@ const {
 
 // A TransformStream's readable/writable halves are created in C++ and share the
 // native ReadableStream/WritableStream prototypes. The public decorations
-// (getReader/getWriter/pipeTo/inspect/transfer/…) are grafted onto those
-// prototypes when these modules load — but a transform-only program may never
+// (getReader/getWriter/pipeTo/inspect/transfer/...) are grafted onto those
+// prototypes when these modules load - but a transform-only program may never
 // touch the ReadableStream/WritableStream globals, so require them eagerly to
 // guarantee the grafts are installed. (readablestream pulls in writablestream.)
 require('internal/webstreams/readablestream');
@@ -80,7 +79,7 @@ const isTransformStream = (value) =>
 const isTransformStreamDefaultController = (value) =>
   value != null &&
   ObjectPrototypeIsPrototypeOf(TransformStreamDefaultControllerNative.prototype,
-                              value);
+                               value);
 
 const hiddenMethodProp = (value) => ({
   __proto__: null, configurable: true, enumerable: false, writable: true, value,
@@ -97,6 +96,7 @@ async function defaultTransformAlgorithm(chunk, controller) {
 /**
  * The public TransformStream interface; the returned object is the C++
  * TransformStream that orchestrates its readable + writable halves.
+ * @returns {TransformStream}
  */
 function TransformStream(
   transformer = kEmptyObject,
@@ -138,7 +138,7 @@ function TransformStream(
   // undefined: both halves then skip the start-promise plumbing entirely and
   // mark their controllers started via the shared per-realm reaction.
   const startAlgorithm = start !== undefined ?
-    (controller) => ReflectApply(start, transformer, [controller]) :
+    (controller) => FunctionPrototypeCall(start, transformer, controller) :
     undefined;
   const transformAlgorithm = transform !== undefined ?
     createPromiseCallback('transformer.transform', transform, transformer) :
@@ -225,11 +225,11 @@ const nativeWritableGet =
 const namedGetters = {
   get readable() {
     if (!isTransformStream(this)) throw new ERR_INVALID_THIS('TransformStream');
-    return ReflectApply(nativeReadableGet, this, []);
+    return FunctionPrototypeCall(nativeReadableGet, this);
   },
   get writable() {
     if (!isTransformStream(this)) throw new ERR_INVALID_THIS('TransformStream');
-    return ReflectApply(nativeWritableGet, this, []);
+    return FunctionPrototypeCall(nativeWritableGet, this);
   },
 };
 const readableGetter =

lib/internal/webstreams/transformstream.js

@@ -1,11 +1,11 @@
 'use strict';
 
 const {
+  FunctionPrototypeCall,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectPrototypeIsPrototypeOf,
   ObjectSetPrototypeOf,
-  ReflectApply,
   Symbol,
   SymbolToStringTag,
 } = primordials;
@@ -102,11 +102,11 @@ const isWritableStream = (value) =>
 const isWritableStreamDefaultWriter = (value) =>
   value != null &&
   ObjectPrototypeIsPrototypeOf(WritableStreamDefaultWriterNative.prototype,
-                              value);
+                               value);
 const isWritableStreamDefaultController = (value) =>
   value != null &&
   ObjectPrototypeIsPrototypeOf(WritableStreamDefaultControllerNative.prototype,
-                              value);
+                               value);
 
 function isWritableStreamLocked(stream) {
   return stream.locked;
@@ -147,9 +147,9 @@ function newWritableStreamFromSink(sink, highWaterMark, sizeMode, sizeFn) {
   const close = sink?.close;
   const abort = sink?.abort;
   const startAlgorithm = start !== undefined ?
-    (controller) => ReflectApply(start, sink, [controller]) :
+    (controller) => FunctionPrototypeCall(start, sink, controller) :
     nonOpStart;
-  // write is passed RAW (no per-call async wrapper): the native controller
+  // Write is passed RAW (no per-call async wrapper): the native controller
   // calls it with `sink` as receiver and handles non-promise returns,
   // thenables, and synchronous throws itself.
   if (write !== undefined) validateFunction(write, 'sink.write');
@@ -167,6 +167,7 @@ function newWritableStreamFromSink(sink, highWaterMark, sizeMode, sizeFn) {
 /**
  * The public WritableStream interface. The returned object is the C++
  * WritableStream; all per-operation logic lives in C++.
+ * @returns {WritableStream}
  */
 function WritableStream(sink = kEmptyObject, strategy = kEmptyObject) {
   if (new.target === undefined)
@@ -305,6 +306,7 @@ ObjectDefineProperty(TransferredWritableStream, 'prototype', {
 /**
  * The public WritableStreamDefaultWriter interface. Acquiring a writer builds
  * the C++ writer (which locks the stream).
+ * @returns {WritableStreamDefaultWriter}
  */
 function WritableStreamDefaultWriter(stream) {
   if (new.target === undefined)

lib/internal/webstreams/writablestream.js

@@ -19,7 +19,7 @@ namespace node {
   V(process_binding_data, process::BindingData)                                \
   V(timers_binding_data, timers::BindingData)                                  \
   V(url_binding_data, url::BindingData)                                        \
-  V(modules_binding_data, modules::BindingData)                               \
+  V(modules_binding_data, modules::BindingData)                                \
   V(webstreams_binding_data, webstreams::BindingData)
 
 #define UNSERIALIZABLE_BINDING_TYPES(V)                                        \