feat: auto-detect AsyncGenerator and StreamTask args

Adds auto-detection in prepareArg so AsyncGenerator and StreamTask
values are automatically piped via MessageChannel without needing
a channel() wrapper.

Co-Authored-By: Claude Sonnet 4.6 <[e-mail]>

src/execute.ts

···
   })();
 }
 
+function isAsyncGenerator(arg: unknown): boolean {
+  return typeof arg === 'object' && arg !== null &&
+    (arg as any)[Symbol.toStringTag] === 'AsyncGenerator';
+}
+
 function prepareArg(arg: unknown): unknown {
+  // Auto-detect AsyncGenerator args — pipe via MessageChannel
+  if (isAsyncGenerator(arg)) {
+    const { port1, port2 } = new MessageChannel();
+    port1.unref();
+    pipeToPort(arg as AsyncIterable<unknown>, port1, DEFAULT_HIGH_WATER);
+    streamPortStack[streamPortStack.length - 1].push(port2);
+    return port2;
+  }
+  // Auto-detect StreamTask args — dispatch to dedicated worker, pipe output
+  if (arg instanceof StreamTask) {
+    const iterable = runStreamOnDedicated(arg.id, arg.args);
+    const { port1, port2 } = new MessageChannel();
+    port1.unref();
+    pipeToPort(iterable, port1, DEFAULT_HIGH_WATER);
+    streamPortStack[streamPortStack.length - 1].push(port2);
+    return port2;
+  }
   if (typeof arg === 'object' && arg !== null && CHANNEL in arg) {
     const data = (arg as any)[CHANNEL];
     let iterable = data.iterable;

test/channel-autodetect.test.ts

···
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { workers } from 'moroutine';
+import { sumStream, uppercaseStream, generate } from './fixtures/channel-autodetect.ts';
+
+describe('AsyncGenerator auto-detection', () => {
+  it('auto-detects AsyncGenerator arg without channel()', async () => {
+    async function* numbers() { yield 1; yield 2; yield 3; }
+    const run = workers(1);
+    try {
+      const result = await run(sumStream(numbers()));
+      assert.equal(result, 6);
+    } finally {
+      run[Symbol.dispose]();
+    }
+  });
+
+  it('auto-detects with streaming output (bidirectional)', async () => {
+    async function* words() { yield 'hello'; yield 'world'; }
+    const run = workers(1);
+    try {
+      const results: string[] = [];
+      for await (const word of run(uppercaseStream(words()))) {
+        results.push(word);
+      }
+      assert.deepEqual(results, ['HELLO', 'WORLD']);
+    } finally {
+      run[Symbol.dispose]();
+    }
+  });
+
+  it('StreamTask arg is auto-detected without channel()', async () => {
+    const run = workers(1);
+    try {
+      const result = await run(sumStream(generate(5)));
+      assert.equal(result, 10);
+    } finally {
+      run[Symbol.dispose]();
+    }
+  });
+});

test/fixtures/channel-autodetect.ts

···
+import { mo } from 'moroutine';
+
+export const sumStream = mo(import.meta, async (input: AsyncIterable<number>): Promise<number> => {
+  let sum = 0;
+  for await (const n of input) {
+    sum += n;
+  }
+  return sum;
+});
+
+export const uppercaseStream = mo(import.meta, async function* (input: AsyncIterable<string>) {
+  for await (const s of input) {
+    yield s.toUpperCase();
+  }
+});
+
+export const generate = mo(import.meta, async function* (n: number) {
+  for (let i = 0; i < n; i++) yield i;
+});