Commit a9134808825 for nodejs

commit a9134808825c1a8647f746b7f6b645b13f83cf63
Author: James M Snell <jasnell@gmail.com>
Date:   Wed Oct 7 02:22:12 2026 +0000

    stream: create stream/iter from() values without async generators

    from() of a string, ArrayBuffer, ArrayBufferView or array of
    Uint8Arrays returns an iterable whose iterators are async generators
    yielding the value's batches. Creating and resuming an async generator
    costs a generator object, its frame and several promises, which
    dominates the cost of a short stream: creating and reading a stream of
    one 16-byte chunk spent a quarter of its time collecting garbage.

    Iterate such values with a small iterator that does what the generator
    did: each iteration starts over and yields the same batches, bounded
    as before, and return() and throw() end it, throw() rejecting with its
    argument.

    Creating and reading a stream of one 16-byte chunk with from() is about
    1.8 times faster, with 900 bytes less allocated per stream.

    Assisted-by: OpenCode
    Signed-off-by: James M Snell <jasnell@gmail.com>
    PR-URL: https://github.com/nodejs/node/pull/66504
    Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
    Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>

diff --git a/lib/internal/streams/iter/from.js b/lib/internal/streams/iter/from.js
index d882e2c5a78..a926eb982bd 100644
--- a/lib/internal/streams/iter/from.js
+++ b/lib/internal/streams/iter/from.js
@@ -1335,6 +1335,64 @@ function fromSync(input) {
   };
 }

+/**
+ * An async iterable yielding the chunks of `batch`, a Uint8Array[], in
+ * batches of at most FROM_BATCH_SIZE chunks, for from() of values that need
+ * no normalization. Each iterator does what an async generator yielding the
+ * batches would, without the generator object and the promises and frames
+ * of resuming it: next() gives the batches, then done; return() and throw()
+ * end the iteration, throw() rejecting with its argument.
+ * @param {Uint8Array[]} batch
+ * @returns {AsyncIterable<Uint8Array[]>}
+ */
+function createBatchSource(batch) {
+  return {
+    __proto__: null,
+    [SymbolAsyncIterator]() {
+      return createBatchIterator(batch);
+    },
+    [kValidatedSource]: true,
+  };
+}
+
+function createBatchIterator(batch) {
+  let index = 0;
+
+  // The next batch, or null once done.
+  function nextBatch() {
+    if (index >= batch.length) {
+      index = batch.length;
+      return null;
+    }
+    if (index === 0 && batch.length <= FROM_BATCH_SIZE) {
+      index = batch.length;
+      return batch;
+    }
+    const start = index;
+    index += FROM_BATCH_SIZE;
+    return ArrayPrototypeSlice(batch, start, index);
+  }
+
+  return ObjectSetPrototypeOf({
+    next() {
+      const value = nextBatch();
+      return PromiseResolve(value === null ?
+        new IterResult(true, undefined) : new IterResult(false, value));
+    },
+    return(value) {
+      index = batch.length;
+      return PromiseResolve(new IterResult(true, value));
+    },
+    throw(error) {
+      index = batch.length;
+      return PromiseReject(error);
+    },
+    [SymbolAsyncIterator]() {
+      return this;
+    },
+  }, null);
+}
+
 /**
  * Create a ByteStreamReadable from a ByteInput or Streamable.
  * @param {string|ArrayBuffer|ArrayBufferView|Iterable|AsyncIterable} input
@@ -1347,14 +1405,7 @@ function from(input) {

   // Check for primitives first (ByteInput)
   if (isPrimitiveChunk(input)) {
-    const chunk = primitiveToUint8Array(input);
-    return {
-      __proto__: null,
-      async *[SymbolAsyncIterator]() {
-        yield [chunk];
-      },
-      [kValidatedSource]: true,
-    };
+    return createBatchSource([primitiveToUint8Array(input)]);
   }

   // Check toAsyncStreamable protocol (takes precedence over toStreamable and
@@ -1392,31 +1443,12 @@ function from(input) {
   // the throughput benefit of batched processing.
   if (ArrayIsArray(input)) {
     if (input.length === 0) {
-      return {
-        __proto__: null,
-        async *[SymbolAsyncIterator]() {
-          // Empty - yield nothing
-        },
-        [kValidatedSource]: true,
-      };
+      return createBatchSource(input);
     }
     if (isUint8Array(input[0])) {
       const allUint8 = ArrayPrototypeEvery(input, isUint8Array);
       if (allUint8) {
-        const batch = input;
-        return {
-          __proto__: null,
-          async *[SymbolAsyncIterator]() {
-            if (batch.length <= FROM_BATCH_SIZE) {
-              yield batch;
-            } else {
-              for (let i = 0; i < batch.length; i += FROM_BATCH_SIZE) {
-                yield ArrayPrototypeSlice(batch, i, i + FROM_BATCH_SIZE);
-              }
-            }
-          },
-          [kValidatedSource]: true,
-        };
+        return createBatchSource(input);
       }
     }
   }
diff --git a/test/parallel/test-stream-iter-from-async.js b/test/parallel/test-stream-iter-from-async.js
index e9199a3654d..cfbb46fa9b6 100644
--- a/test/parallel/test-stream-iter-from-async.js
+++ b/test/parallel/test-stream-iter-from-async.js
@@ -828,7 +828,37 @@ async function testFromReturnsItsOwnResults() {
   }
 }

+// from() of a value needing no normalization reads like an async generator
+// yielding its batches: each iteration starts over, return() and throw()
+// end it, and arrays are yielded in bounded batches.
+async function testFromValueIteration() {
+  const chunk = new Uint8Array([1]);
+  const source = from(chunk);
+  for (let i = 0; i < 2; i++) {
+    const batches = await Array.fromAsync(source);
+    assert.deepStrictEqual(batches, [[chunk]]);
+  }
+
+  let iterator = source[Symbol.asyncIterator]();
+  assert.deepStrictEqual({ ...await iterator.return(5) },
+                         { done: true, value: 5 });
+  assert.strictEqual((await iterator.next()).done, true);
+
+  iterator = source[Symbol.asyncIterator]();
+  assert.deepStrictEqual((await iterator.next()).value, [chunk]);
+  const error = new Error('thrown');
+  await assert.rejects(iterator.throw(error), error);
+  assert.strictEqual((await iterator.next()).done, true);
+
+  const chunks = Array.from({ length: 300 }, () => chunk);
+  const lengths = (await Array.fromAsync(from(chunks)))
+    .map((batch) => batch.length);
+  assert.deepStrictEqual(lengths, [128, 128, 44]);
+  assert.deepStrictEqual(await Array.fromAsync(from([])), []);
+}
+
 Promise.all([
+  testFromValueIteration(),
   testFromReturnsItsOwnResults(),
   testFromString(),
   testFromAsyncGenerator(),