stream: prefer sync iterator in fromSync

When an input provides Symbol.iterator, fromSync() should consume the
synchronous iterator instead of rejecting the input because it also
exposes an asynchronous or promise-like protocol.

Continue rejecting async-only iterables and promise/thenable-only
inputs, but allow sync iterables that also define Symbol.asyncIterator
or then().

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: #64294
Fixes: #64292
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: trivikr

lib/internal/streams/iter/from.js

@@ -484,15 +484,20 @@ function fromSync(input) {
     return fromSync(input[toStreamable]());
   }
 
-  // Reject explicit async inputs
-  if (isAsyncIterable(input)) {
+  const isIterable = isSyncIterable(input);
+
+  // Reject explicit async-only inputs
+  if (!isIterable && isAsyncIterable(input)) {
     throw new ERR_INVALID_ARG_TYPE(
       'input',
       'a synchronous input (not AsyncIterable)',
       input,
     );
   }
-  if (typeof input === 'object' && input !== null && typeof input.then === 'function') {
+  if (!isIterable &&
+      typeof input === 'object' &&
+      input !== null &&
+      typeof input.then === 'function') {
     throw new ERR_INVALID_ARG_TYPE(
       'input',
       'a synchronous input (not Promise)',
@@ -501,7 +506,7 @@ function fromSync(input) {
   }
 
   // Must be a SyncStreamable
-  if (!isSyncIterable(input)) {
+  if (!isIterable) {
     throw new ERR_INVALID_ARG_TYPE(
       'input',
       ['string', 'ArrayBuffer', 'ArrayBufferView', 'Iterable', 'toStreamable'],

test/parallel/test-stream-iter-from-sync.js

@@ -3,7 +3,7 @@
 
 const common = require('../common');
 const assert = require('assert');
-const { fromSync } = require('stream/iter');
+const { fromSync, textSync } = require('stream/iter');
 
 function testFromSyncString() {
   // String input should be UTF-8 encoded
@@ -186,6 +186,30 @@ function testFromSyncRejectsAsyncIterable() {
   assert.throws(() => fromSync(gen()), { code: 'ERR_INVALID_ARG_TYPE' });
 }
 
+function testFromSyncPrefersIteratorForDualIterable() {
+  const input = {
+    *[Symbol.iterator]() {
+      yield new TextEncoder().encode('sync');
+    },
+    async *[Symbol.asyncIterator]() {
+      yield new TextEncoder().encode('async');
+    },
+  };
+
+  assert.strictEqual(textSync(fromSync(input)), 'sync');
+}
+
+function testFromSyncPrefersIteratorForThenableIterable() {
+  const input = {
+    then() {},
+    *[Symbol.iterator]() {
+      yield new TextEncoder().encode('sync');
+    },
+  };
+
+  assert.strictEqual(textSync(fromSync(input)), 'sync');
+}
+
 // Promise rejected
 function testFromSyncRejectsPromise() {
   assert.throws(() => fromSync(Promise.resolve('hello')),
@@ -232,6 +256,8 @@ Promise.all([
   testFromSyncTopLevelProtocolOverIterator(),
   testFromSyncIgnoresAsyncStreamable(),
   testFromSyncRejectsAsyncIterable(),
+  testFromSyncPrefersIteratorForDualIterable(),
+  testFromSyncPrefersIteratorForThenableIterable(),
   testFromSyncRejectsPromise(),
   testFromSyncDataView(),
 ]).then(common.mustCall());