@scriptc/compiler 0.4.3 → 0.4.5

package/dist/frontend/lowering/lower-stream.js

@@ -2089,7 +2089,7 @@ function fromGenHelpers(lowerer, gen, loc) {
  * lifted function per iterator class takes the iterator and answers the
  * object, whose `next` closure captures it. */
 function classIteratorObject(lowerer, cit, iter, loc) {
-    const key = `streamFromIter:${cit.iterT.className}`;
+    const key = `streamFromIter:${cit.iterT.kind === "object" ? cit.iterT.className : typeKey(cit.iterT)}`;
     let name = lowerer.valueHelpers.get(key);
     if (!name) {
         name = keyedHelperName(lowerer, "%stream.fromIter", key);
@@ -2117,7 +2117,7 @@ function classIteratorObject(lowerer, cit, iter, loc) {
                 {
                     kind: "varDecl",
                     localId: r.id,
-                    init: classIteratorNextCall(lowerer, cit, varRef(it.id, cit.iterT, loc), loc),
+                    init: classIteratorNextCall(lowerer, cit, varRef(it.id, cit.iterT, loc), null, loc),
                     loc,
                 },
                 {
@@ -2347,6 +2347,90 @@ export function streamClassAliasDecl(lowerer, nameNode, init) {
  * makeAsyncIterable — every stage position renders the same "body"
  * clause). finished() keeps its narrower isNodeStream wording. */
 const PIPELINE_STAGE_EXPECTED = "of type function or an instance of Blob, ReadableStream, WritableStream, Stream, Iterable, AsyncIterable, or Promise or { readable, writable } pair";
+/** A checked-dynamic pipeline stage (an untyped source or destination):
+ * a boxed native stream unwraps at run time; other values (functions,
+ * pairs) throw the not-supported Error there. */
+function unboxDynStage(lowerer, v, node) {
+    noteUntypedStreamFlow(lowerer, null);
+    return {
+        kind: "libCall",
+        fn: "stream.unboxDyn",
+        args: [
+            v,
+            strLit(lowerer.dynNodeStreams
+                ? "pipeline stages other than native streams (JavaScript stream objects, iterables, generators, plain functions, and { readable, writable } pairs) are not supported yet"
+                : "pipeline stages other than native streams (iterables, generators, plain functions, and { readable, writable } pairs) are not supported yet", locOf(node)),
+        ],
+        type: { kind: "object", className: "%Duplex" },
+        loc: locOf(node),
+    };
+}
+/** pipeline() whose first stage is a stream argument (not a function
+ * stage, an iterable of a static type, or a cipher value), lowered here.
+ * When the value is checked-dynamic, Node keeps a stream there and pipes
+ * it, and keeps an iterable (a string, an array, a generator, any value
+ * with an iterator method) and pumps it into the next stage. The value is
+ * evaluated once, and stream.dynIterableSource picks the lowering at run
+ * time. Null when the first stage is not such an argument. */
+function lowerDynSourcePipeline(lowerer, node, loc, build) {
+    if (pipelineStageFunction(lowerer, node) !== null)
+        return null;
+    if (iterableSourceType(lowerer, node) !== null || isValueStream(lowerer, node))
+        return null;
+    let value = lowerer.lowerExpr(node);
+    // A Set, a Map or a generator object is iterated through its
+    // checked-dynamic value.
+    if (BOXED_SOURCE_KINDS.has(value.type.kind) && lowerer.dynConvertible(value.type)) {
+        value = { kind: "dynFrom", value, type: DYN, loc: value.loc };
+    }
+    if (value.type.kind !== "dyn") {
+        let stream;
+        try {
+            stream = streamArgOf(lowerer, node, value, "pipeline");
+        }
+        catch (e) {
+            if (e instanceof StreamArgTypeThrow)
+                return e.expr;
+            throw e;
+        }
+        return build({ expr: stream, iterable: false });
+    }
+    const local = lowerer.declareHiddenLocal("%pipelineSource", DYN);
+    const ref = varRef(local.id, DYN, loc);
+    const stream = build({ expr: unboxDynStage(lowerer, ref, node), iterable: false });
+    const iterable = build({ expr: ref, iterable: true });
+    const type = stream.type;
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "varDecl", localId: local.id, init: value, loc }],
+        result: {
+            kind: "ternary",
+            cond: { kind: "libCall", fn: "stream.dynIterableSource", args: [ref], type: BOOL, loc },
+            then: lowerer.coerceToExpected(iterable, type),
+            else_: stream,
+            type,
+            loc,
+        },
+        type,
+        loc,
+    };
+}
+/** The static types of a pipeline source that lowerDynSourcePipeline boxes
+ * as checked-dynamic values. An array or a string reaches it when the
+ * checker types the argument as any while its value keeps a static type. */
+const BOXED_SOURCE_KINDS = new Set([
+    "set",
+    "map",
+    "generator",
+    "array",
+    "string",
+]);
+/** lowerPipelineStages' source arguments for a checked-dynamic first stage. */
+function stagesSource(src) {
+    if (src === null)
+        return [undefined, undefined];
+    return src.iterable ? [undefined, src.expr] : [new Map([[0, src.expr]]), undefined];
+}
 /** A stream-rooted argument, lowered — or the pointed fence (pipeline's
  * iterable/generator/function stages have no lowering yet). `what` picks
  * the validation ladder: finished() rejects EVERY non-stream through
@@ -2354,7 +2438,10 @@ const PIPELINE_STAGE_EXPECTED = "of type function or an instance of Blob, Readab
  * { readable, writable } pairs — those shapes fence instead of throwing
  * a ladder Node never throws. */
 function lowerStreamArg(lowerer, node, what) {
-    const lowered = lowerer.lowerExpr(node);
+    return streamArgOf(lowerer, node, lowerer.lowerExpr(node), what);
+}
+/** lowerStreamArg over the argument's lowered value. */
+function streamArgOf(lowerer, node, lowered, what) {
     // A Hash, Hmac, Cipheriv or Decipheriv stage is its Transform; pipeline
     // and compose stages keep the value alive until the stream settles.
     const v = isValueStream(lowerer, node)
@@ -2363,21 +2450,8 @@ function lowerStreamArg(lowerer, node, what) {
     // A checked-dynamic pipeline stage (an untyped source or destination):
     // a boxed native stream unwraps at run time; other values (iterables,
     // functions) throw the not-supported Error there.
-    if (v.type.kind === "dyn" && what === "pipeline") {
-        noteUntypedStreamFlow(lowerer, null);
-        return {
-            kind: "libCall",
-            fn: "stream.unboxDyn",
-            args: [
-                v,
-                strLit(lowerer.dynNodeStreams
-                    ? "pipeline stages other than native streams (JavaScript stream objects, iterables, generators, plain functions, and { readable, writable } pairs) are not supported yet"
-                    : "pipeline stages other than native streams (iterables, generators, plain functions, and { readable, writable } pairs) are not supported yet", locOf(node)),
-            ],
-            type: { kind: "object", className: "%Duplex" },
-            loc: locOf(node),
-        };
-    }
+    if (v.type.kind === "dyn" && what === "pipeline")
+        return unboxDynStage(lowerer, v, node);
     const info = v.type.kind === "object" ? lowerer.classes.get(v.type.className) : undefined;
     if (!streamSidesOf(lowerer, info)) {
         // A provably-non-stream value in a JS source (the invalid-input
@@ -2655,59 +2729,69 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
                 ? pipelineOptions(lowerer, lastArg)
                 : null;
             const stageArgs = opts ? args.slice(0, -1) : args;
-            if (hasPipelineFunctionStage(lowerer, stageArgs)) {
-                const staged = lowerPipelineStages(lowerer, stageArgs, loc);
-                const type = staged.destPromise ?? { kind: "promise", inner: VOID };
-                // A promise destination's value settles the result (same type).
-                if (!opts) {
-                    return staged.wrap({
-                        kind: "libCall",
-                        fn: "sp.pipelineStages",
-                        args: staged.args,
-                        type,
-                        loc,
-                    });
-                }
-                // the options: end, and the signal (flags bit 6)
-                const flagsArg = staged.args[3];
-                if (flagsArg.kind !== "numLit")
-                    throw new InternalCompilerError("pipeline flags not a literal");
-                const args = [...staged.args, boolLit(opts.end, loc)];
-                if (opts.signal) {
-                    args[3] = numLit(flagsArg.value | 64, loc);
-                    args.push(opts.signal);
-                }
-                return staged.wrap({ kind: "libCall", fn: "sp.pipelineStagesOpts", args, type, loc });
-            }
-            let streams;
-            try {
-                streams = stageArgs.map((a) => lowerStreamArg(lowerer, a, "pipeline"));
-            }
-            catch (e) {
-                if (e instanceof StreamArgTypeThrow)
-                    return e.expr;
-                throw e;
-            }
-            if (opts) {
-                const head = [numLit(streams.length, loc), ...streams, boolLit(opts.end, loc)];
-                return {
-                    kind: "libCall",
-                    fn: opts.signal ? "sp.pipelineOptsSignal" : "sp.pipelineOpts",
-                    args: opts.signal ? [...head, opts.signal] : head,
-                    type: { kind: "promise", inner: VOID },
-                    loc,
-                };
-            }
-            return {
+            const build = (src) => lowerPromisePipeline(lowerer, stageArgs, opts, src, loc);
+            return lowerDynSourcePipeline(lowerer, stageArgs[0], loc, build) ?? build(null);
+        }
+        return null;
+    }
+    return lowerStreamModuleCallbackCall(lowerer, call, bi, loc);
+}
+/** stream/promises pipeline(...stages[, options]), with the first stage
+ * pre-lowered when it is checked-dynamic (lowerDynSourcePipeline). */
+function lowerPromisePipeline(lowerer, stageArgs, opts, src, loc) {
+    if (src?.iterable === true || hasPipelineFunctionStage(lowerer, stageArgs)) {
+        const staged = lowerPipelineStages(lowerer, stageArgs, loc, ...stagesSource(src));
+        const type = staged.destPromise ?? { kind: "promise", inner: VOID };
+        // A promise destination's value settles the result (same type).
+        if (!opts) {
+            return staged.wrap({
                 kind: "libCall",
-                fn: "sp.pipeline",
-                args: [numLit(streams.length, loc), ...streams],
-                type: { kind: "promise", inner: VOID },
+                fn: "sp.pipelineStages",
+                args: staged.args,
+                type,
                 loc,
-            };
+            });
         }
-        return null;
+        // the options: end, and the signal (flags bit 6)
+        const flagsArg = staged.args[3];
+        if (flagsArg.kind !== "numLit")
+            throw new InternalCompilerError("pipeline flags not a literal");
+        const args = [...staged.args, boolLit(opts.end, loc)];
+        if (opts.signal) {
+            args[3] = numLit(flagsArg.value | 64, loc);
+            args.push(opts.signal);
+        }
+        return staged.wrap({ kind: "libCall", fn: "sp.pipelineStagesOpts", args, type, loc });
+    }
+    let streams;
+    try {
+        streams = stageArgs.map((a, i) => i === 0 && src !== null ? src.expr : lowerStreamArg(lowerer, a, "pipeline"));
+    }
+    catch (e) {
+        if (e instanceof StreamArgTypeThrow)
+            return e.expr;
+        throw e;
     }
+    if (opts) {
+        const head = [numLit(streams.length, loc), ...streams, boolLit(opts.end, loc)];
+        return {
+            kind: "libCall",
+            fn: opts.signal ? "sp.pipelineOptsSignal" : "sp.pipelineOpts",
+            args: opts.signal ? [...head, opts.signal] : head,
+            type: { kind: "promise", inner: VOID },
+            loc,
+        };
+    }
+    return {
+        kind: "libCall",
+        fn: "sp.pipeline",
+        args: [numLit(streams.length, loc), ...streams],
+        type: { kind: "promise", inner: VOID },
+        loc,
+    };
+}
+/** The node:stream and stream/consumers members of lowerStreamModuleCall. */
+function lowerStreamModuleCallbackCall(lowerer, call, bi, loc) {
     if (bi.module === "stream/consumers") {
         const args = call.arguments.nodes;
         // text/json/buffer/arrayBuffer(stream) → a pending promise the
@@ -2833,69 +2917,77 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
         if (args.length < 3) {
             lowerer.noLowering(`pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams, callback)");
         }
-        if (hasPipelineFunctionStage(lowerer, args.slice(0, -1))) {
-            const staged = lowerPipelineStages(lowerer, args.slice(0, -1), loc);
-            const cbNode = args[args.length - 1];
-            const cbParams = ts.isArrowFunction(cbNode) || ts.isFunctionExpression(cbNode)
-                ? cbNode.parameters.nodes.length
-                : 0;
-            if (staged.dest === 2 || (staged.dest === 1 && cbParams > 1)) {
-                // callback(err, value): the destination's value (undefined for
-                // an async generator) reaches the callback through the
-                // checked-dynamic path.
-                const cb = lowerer.lowerExprExpecting(args[args.length - 1], DYN);
-                // SCR_PIPE_TYPED_CB: a typed callback whose error parameter cannot
-                // hold undefined takes null for no error; others take undefined.
-                const stagedArgs = [...staged.args];
-                const flagsArg = stagedArgs[3];
-                if (flagsArg.kind !== "numLit")
-                    throw new InternalCompilerError("pipeline flags not a literal");
-                if (!isJsSourceFile(ts.getSourceFileOfNode(call)) &&
-                    !callbackErrorAdmitsUndefined(lowerer, cb))
-                    stagedArgs[3] = numLit(flagsArg.value | 128, loc);
-                return staged.wrap({
-                    kind: "libCall",
-                    fn: "stream.pipelineStagesDyn",
-                    args: [...stagedArgs, cb],
-                    type: staged.last,
-                    loc,
-                });
-            }
-            const { cb, dyn } = lowerEosCallback(lowerer, "pipeline", args[args.length - 1], staged.last);
+        const build = (src) => lowerCallbackPipeline(lowerer, call, args, src, loc);
+        return lowerDynSourcePipeline(lowerer, args[0], loc, build) ?? build(null);
+    }
+    if (bi.member === "compose") {
+        if (call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
+            lowerer.noLowering("compose with spread arguments", call, "pass the streams directly");
+        }
+        return lowerStreamCompose(lowerer, call.arguments.nodes, loc);
+    }
+    return null;
+}
+/** pipeline(...stages, callback), with the first stage pre-lowered when it
+ * is checked-dynamic (lowerDynSourcePipeline). */
+function lowerCallbackPipeline(lowerer, call, args, src, loc) {
+    if (src?.iterable === true || hasPipelineFunctionStage(lowerer, args.slice(0, -1))) {
+        const staged = lowerPipelineStages(lowerer, args.slice(0, -1), loc, ...stagesSource(src));
+        const cbNode = args[args.length - 1];
+        const cbParams = ts.isArrowFunction(cbNode) || ts.isFunctionExpression(cbNode)
+            ? cbNode.parameters.nodes.length
+            : 0;
+        if (staged.dest === 2 || (staged.dest === 1 && cbParams > 1)) {
+            // callback(err, value): the destination's value (undefined for
+            // an async generator) reaches the callback through the
+            // checked-dynamic path.
+            const cb = lowerer.lowerExprExpecting(args[args.length - 1], DYN);
+            // SCR_PIPE_TYPED_CB: a typed callback whose error parameter cannot
+            // hold undefined takes null for no error; others take undefined.
+            const stagedArgs = [...staged.args];
+            const flagsArg = stagedArgs[3];
+            if (flagsArg.kind !== "numLit")
+                throw new InternalCompilerError("pipeline flags not a literal");
+            if (!isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+                !callbackErrorAdmitsUndefined(lowerer, cb))
+                stagedArgs[3] = numLit(flagsArg.value | 128, loc);
             return staged.wrap({
                 kind: "libCall",
-                fn: dyn ? "stream.pipelineStagesDyn" : "stream.pipelineStages",
-                args: [...staged.args, cb],
+                fn: "stream.pipelineStagesDyn",
+                args: [...stagedArgs, cb],
                 type: staged.last,
                 loc,
             });
         }
-        let streams;
-        try {
-            streams = args.slice(0, -1).map((a) => lowerStreamArg(lowerer, a, "pipeline"));
-        }
-        catch (e) {
-            if (e instanceof StreamArgTypeThrow)
-                return e.expr;
-            throw e;
-        }
-        const last = streams[streams.length - 1];
-        const { cb, dyn } = lowerEosCallback(lowerer, "pipeline", args[args.length - 1], last.type);
-        return {
+        const { cb, dyn } = lowerEosCallback(lowerer, "pipeline", args[args.length - 1], staged.last);
+        return staged.wrap({
             kind: "libCall",
-            fn: dyn ? "stream.pipelineDyn" : "stream.pipeline",
-            args: [numLit(streams.length, loc), ...streams, cb],
-            type: last.type,
+            fn: dyn ? "stream.pipelineStagesDyn" : "stream.pipelineStages",
+            args: [...staged.args, cb],
+            type: staged.last,
             loc,
-        };
+        });
     }
-    if (bi.member === "compose") {
-        if (call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
-            lowerer.noLowering("compose with spread arguments", call, "pass the streams directly");
-        }
-        return lowerStreamCompose(lowerer, call.arguments.nodes, loc);
+    let streams;
+    try {
+        streams = args
+            .slice(0, -1)
+            .map((a, i) => (i === 0 && src !== null ? src.expr : lowerStreamArg(lowerer, a, "pipeline")));
     }
-    return null;
+    catch (e) {
+        if (e instanceof StreamArgTypeThrow)
+            return e.expr;
+        throw e;
+    }
+    const last = streams[streams.length - 1];
+    const { cb, dyn } = lowerEosCallback(lowerer, "pipeline", args[args.length - 1], last.type);
+    return {
+        kind: "libCall",
+        fn: dyn ? "stream.pipelineDyn" : "stream.pipeline",
+        args: [numLit(streams.length, loc), ...streams, cb],
+        type: last.type,
+        loc,
+    };
 }
 /** The function a pipeline() argument writes or names, or null when the
  * argument is not a function stage. */
@@ -3187,6 +3279,298 @@ function lowerWebStreamSource(lowerer, node, elemT, loc) {
         out,
     };
 }
+/** A checked-dynamic pipeline source that is an iterable at run time
+ * (stream.dynIterableSource), as an async generator closure that iterates
+ * it as Node's pipeline does with `for await`: the value's async iterator,
+ * or its sync iterator stepped like the typed iterable sources. Each value
+ * is yielded; leaving early closes the iterator through its return(). */
+function lowerDynIterableSource(lowerer, value, loc) {
+    const out = {
+        kind: "generator",
+        async: true,
+        yieldT: DYN,
+        retT: VOID,
+        nextT: UNDEFINED_T,
+    };
+    const genResultT = genResultRecord(DYN, VOID, lowerer.shapes, lowerer.unions);
+    if (!genResultT)
+        return null;
+    const key = "dynIterableSource";
+    let maker = lowerer.valueHelpers.get(key);
+    if (!maker) {
+        maker = `%stream.dynIterableSource.${lowerer.valueHelpers.size}`;
+        const genName = `${maker}.gen`;
+        const frame = new LiftedFrame(loc);
+        const srcId = frame.local("src", DYN, false);
+        const itId = frame.local("it", DYN, false);
+        const syncId = frame.local("sync", BOOL, false);
+        const nextId = frame.local("next", DYN, false);
+        const stepId = frame.local("step", DYN, true);
+        const valueId = frame.local("value", DYN, true);
+        const activeId = frame.local("active", BOOL, true);
+        const closeId = frame.local("close", DYN, false);
+        const it = () => varRef(itId, DYN, loc);
+        const sync = () => varRef(syncId, BOOL, loc);
+        const step = () => varRef(stepId, DYN, loc);
+        const value = () => varRef(valueId, DYN, loc);
+        // for await over a sync iterator awaits each value, the final one
+        // included (CreateAsyncFromSyncIterator): an object (a promise or a
+        // thenable) passes on its result
+        const awaitsValue = () => ({
+            kind: "logical",
+            op: "&&",
+            left: sync(),
+            right: {
+                kind: "logical",
+                op: "||",
+                left: { kind: "dynTest", test: "promise", value: value(), type: BOOL, loc },
+                right: {
+                    kind: "logical",
+                    op: "&&",
+                    left: {
+                        kind: "dynTest",
+                        test: "nullish",
+                        negated: true,
+                        value: value(),
+                        type: BOOL,
+                        loc,
+                    },
+                    right: { kind: "dynTest", test: "object", value: value(), type: BOOL, loc },
+                    type: BOOL,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            },
+            type: BOOL,
+            loc,
+        });
+        const get = (obj, name) => ({
+            kind: "dynKeyGet",
+            value: obj,
+            key: strLit(name, loc),
+            type: DYN,
+            loc,
+        });
+        const awaitDyn = (v) => ({
+            kind: "libCall",
+            fn: "async.awaitDyn",
+            args: [v],
+            type: DYN,
+            loc,
+        });
+        const call = (callee, calleeName) => ({
+            kind: "dynCall",
+            callee,
+            receiver: it(),
+            calleeName,
+            args: [],
+            type: DYN,
+            loc,
+        });
+        const setActive = (on) => ({
+            kind: "assign",
+            localId: activeId,
+            value: boolLit(on, loc),
+            loc,
+        });
+        const nextCall = () => call(varRef(nextId, DYN, loc), "iterator method");
+        const body = [
+            {
+                kind: "varDecl",
+                localId: itId,
+                init: {
+                    kind: "libCall",
+                    fn: "dyn.iteratorResult",
+                    args: [
+                        {
+                            kind: "libCall",
+                            fn: "dyn.asyncIteratorOpen",
+                            args: [varRef(srcId, DYN, loc), strLit("", loc)],
+                            type: DYN,
+                            loc,
+                        },
+                    ],
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "varDecl",
+                localId: syncId,
+                init: { kind: "libCall", fn: "dyn.asyncIteratorWasSync", args: [], type: BOOL, loc },
+                loc,
+            },
+            { kind: "varDecl", localId: nextId, init: get(it(), "next"), loc },
+            { kind: "varDecl", localId: stepId, init: dynUndefinedExpr(loc), loc },
+            { kind: "varDecl", localId: valueId, init: dynUndefinedExpr(loc), loc },
+            { kind: "varDecl", localId: activeId, init: boolLit(false, loc), loc },
+            {
+                kind: "tryCatch",
+                tryBody: [
+                    {
+                        kind: "while",
+                        cond: boolLit(true, loc),
+                        body: [
+                            setActive(false),
+                            {
+                                kind: "assign",
+                                localId: stepId,
+                                value: {
+                                    kind: "libCall",
+                                    fn: "dyn.iteratorResult",
+                                    args: [
+                                        {
+                                            kind: "ternary",
+                                            cond: sync(),
+                                            then: nextCall(),
+                                            else_: awaitDyn(nextCall()),
+                                            type: DYN,
+                                            loc,
+                                        },
+                                    ],
+                                    type: DYN,
+                                    loc,
+                                },
+                                loc,
+                            },
+                            {
+                                kind: "if",
+                                cond: {
+                                    kind: "dynTest",
+                                    test: "truthy",
+                                    value: get(step(), "done"),
+                                    type: BOOL,
+                                    loc,
+                                },
+                                // a sync iterator's final value is awaited too: a rejection
+                                // rejects the pump, and the finished iterator is not closed.
+                                // An async iterator's final value is not read.
+                                then: [
+                                    {
+                                        kind: "if",
+                                        cond: sync(),
+                                        then: [
+                                            { kind: "assign", localId: valueId, value: get(step(), "value"), loc },
+                                            {
+                                                kind: "if",
+                                                cond: awaitsValue(),
+                                                then: [{ kind: "exprStmt", expr: awaitDyn(value()), loc }],
+                                                else_: null,
+                                                loc,
+                                            },
+                                        ],
+                                        else_: null,
+                                        loc,
+                                    },
+                                    { kind: "break", loc },
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                            setActive(true),
+                            { kind: "assign", localId: valueId, value: get(step(), "value"), loc },
+                            // a rejection here closes the iterator
+                            {
+                                kind: "if",
+                                cond: awaitsValue(),
+                                then: [{ kind: "assign", localId: valueId, value: awaitDyn(value()), loc }],
+                                else_: null,
+                                loc,
+                            },
+                            {
+                                kind: "exprStmt",
+                                expr: { kind: "yieldExpr", value: value(), type: VOID, loc },
+                                loc,
+                            },
+                        ],
+                        loc,
+                    },
+                ],
+                catchBody: null,
+                catchLocalId: null,
+                finallyBody: [
+                    {
+                        kind: "if",
+                        cond: varRef(activeId, BOOL, loc),
+                        then: [
+                            { kind: "varDecl", localId: closeId, init: get(it(), "return"), loc },
+                            {
+                                kind: "if",
+                                cond: {
+                                    kind: "unary",
+                                    op: "!",
+                                    operand: {
+                                        kind: "dynTest",
+                                        test: "nullish",
+                                        value: varRef(closeId, DYN, loc),
+                                        type: BOOL,
+                                        loc,
+                                    },
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: [
+                                    {
+                                        kind: "exprStmt",
+                                        expr: awaitDyn(call(varRef(closeId, DYN, loc), "iterator return")),
+                                        loc,
+                                    },
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                        ],
+                        else_: null,
+                        loc,
+                    },
+                ],
+                loc,
+            },
+            { kind: "return", value: null, loc },
+        ];
+        const srcLocal = frame.locals.find((l) => l.id === srcId);
+        srcLocal.boxed = true;
+        lowerer.valueHelpers.set(key, maker);
+        lowerer.liftedFns.push({
+            name: genName,
+            params: [],
+            returnType: VOID,
+            async: true,
+            captures: [{ localId: srcId, name: "src", type: DYN }],
+            locals: frame.locals,
+            body,
+            generator: { yieldT: DYN, nextT: UNDEFINED_T, resultType: genResultT },
+            loc,
+        });
+        const makerSrc = { id: "src.0", name: "src", type: DYN, mutable: false, boxed: true };
+        lowerer.liftedFns.push({
+            name: maker,
+            params: [{ localId: makerSrc.id, name: makerSrc.name, type: DYN }],
+            returnType: funcOf([], out),
+            locals: [makerSrc],
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "closure",
+                        fnName: genName,
+                        captures: [makerSrc.id],
+                        type: funcOf([], out),
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return {
+        closure: { kind: "call", callee: maker, args: [value], type: funcOf([], out), loc },
+        out,
+    };
+}
 function lowerIterableSource(lowerer, node, fn, loc) {
     if (fn === null) {
         const webElem = staticReadableStreamElementType(lowerer, node);
@@ -3316,7 +3700,7 @@ function lowerIterableSource(lowerer, node, fn, loc) {
  * pipeline passes it: makeAsyncIterable answers the previous stream
  * itself (a Readable is async iterable) or the previous stage's
  * generator. */
-function lowerPipelineStages(lowerer, stageArgs, loc, preLowered) {
+function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource) {
     if (stageArgs.length > 52) {
         lowerer.noLowering("pipeline with function stages and more than 52 stages", stageArgs[52], "split the pipeline");
     }
@@ -3336,6 +3720,16 @@ function lowerPipelineStages(lowerer, stageArgs, loc, preLowered) {
     const argOrder = [];
     for (let j = 0; j < stageArgs.length; j++) {
         const arg = stageArgs[j];
+        if (j === 0 && dynSource !== undefined) {
+            const source = lowerDynIterableSource(lowerer, dynSource, loc);
+            if (source === null)
+                lowerer.noLowering("pipeline over this source", arg);
+            positions += 1;
+            argOrder.push({ list: stages, index: stages.length });
+            stages.push(source.closure);
+            srcT = source.out;
+            continue;
+        }
         // compose's head and tail functions arrive as Duplex.from streams
         const fn = preLowered?.has(j) ? null : pipelineStageFunction(lowerer, arg);
         const syncSourceFn = j === 0 &&