@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -2347,19 +2347,23 @@ 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. */
+/** A checked-dynamic pipeline stage taken as a stream: a boxed native
+ * stream unwraps at run time, and a value that is not stream-like or a
+ * function (an iterable after the first stage) becomes Duplex.from of it,
+ * as pipelineImpl's last branch does. Stream-like objects, web streams and
+ * { readable, writable } pairs throw the not-supported Error there, and so
+ * do functions, which reach this lowering only past
+ * MAX_DYN_FUNCTION_STAGES. */
 function unboxDynStage(lowerer, v, node) {
     noteUntypedStreamFlow(lowerer, null);
     return {
         kind: "libCall",
-        fn: "stream.unboxDyn",
+        fn: "stream.unboxDynStage",
         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)),
+                ? "pipeline stages other than native streams, iterables and functions (JavaScript stream objects, web streams, { readable, writable } pairs after the first stage, and functions after the first three untyped stages) are not supported yet"
+                : "pipeline stages other than native streams, iterables and functions (web streams, { readable, writable } pairs after the first stage, and functions after the first three untyped stages) are not supported yet", locOf(node)),
         ],
         type: { kind: "object", className: "%Duplex" },
         loc: locOf(node),
@@ -2425,12 +2429,100 @@ const BOXED_SOURCE_KINDS = new Set([
     "array",
     "string",
 ]);
+/** The most checked-dynamic stages after the first that a pipeline
+ * branches on as functions; each one doubles the lowered pipeline calls. */
+const MAX_DYN_FUNCTION_STAGES = 3;
+/** pipeline() whose stages after the first include untyped values:
+ * pipelineImpl calls a stage that is a function with the previous stage
+ * and { signal }, and pipes into or takes any other value, so the call is
+ * lowered once per combination of those stages being functions or not,
+ * up to MAX_DYN_FUNCTION_STAGES of them, and a typeof test on each
+ * picks the branch at run time. The arguments other than function stages
+ * are evaluated first, in argument order. */
+function lowerDynStagePipeline(lowerer, stageArgs, src, loc, build) {
+    const candidates = [];
+    for (let j = 1; j < stageArgs.length; j++) {
+        const arg = stageArgs[j];
+        if (pipelineStageFunction(lowerer, arg) !== null || isValueStream(lowerer, arg))
+            continue;
+        if ((lowerer.typeOf(arg).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+            candidates.push(j);
+        }
+    }
+    if (candidates.length === 0)
+        return build({ source: src, bound: new Map(), fns: new Set() });
+    const stmts = [];
+    const bind = (init) => {
+        const local = lowerer.declareHiddenLocal("%pipelineArg", init.type);
+        stmts.push({ kind: "varDecl", localId: local.id, init, loc: init.loc });
+        return varRef(local.id, init.type, init.loc);
+    };
+    const source = src !== null && !src.iterable ? { expr: bind(src.expr), iterable: false } : src;
+    const bound = new Map();
+    let preSource;
+    for (let j = src !== null ? 1 : 0; j < stageArgs.length; j++) {
+        const arg = stageArgs[j];
+        if (pipelineStageFunction(lowerer, arg) !== null)
+            continue;
+        if (j === 0 && iterableSourceType(lowerer, arg) !== null) {
+            const lowered = lowerIterableSource(lowerer, arg, null, loc);
+            if (lowered === null)
+                lowerer.noLowering("pipeline over this source", arg);
+            preSource = { closure: bind(lowered.closure), out: lowered.out };
+            continue;
+        }
+        let value = lowerer.lowerExpr(arg);
+        // an untyped array, string, Set, Map or generator object that keeps
+        // its static type is taken through its checked-dynamic value
+        if (candidates.includes(j) &&
+            BOXED_SOURCE_KINDS.has(value.type.kind) &&
+            lowerer.dynConvertible(value.type)) {
+            value = { kind: "dynFrom", value, type: DYN, loc: value.loc };
+        }
+        bound.set(j, bind(value));
+    }
+    const dynStages = candidates
+        .filter((j) => bound.get(j).type.kind === "dyn")
+        .slice(0, MAX_DYN_FUNCTION_STAGES);
+    const branch = (i, fns) => {
+        if (i === dynStages.length)
+            return build({ source, bound, preSource, fns });
+        const j = dynStages[i];
+        const asStream = branch(i + 1, fns);
+        const asFunction = branch(i + 1, new Set([...fns, j]));
+        // a function destination's promise resolves to its value
+        const type = asFunction.type.kind === "promise" && asFunction.type.inner.kind === "dyn"
+            ? asFunction.type
+            : asStream.type;
+        return {
+            kind: "ternary",
+            cond: { kind: "dynTest", test: "function", value: bound.get(j), type: BOOL, loc },
+            then: lowerer.coerceToExpected(asFunction, type),
+            else_: lowerer.coerceToExpected(asStream, type),
+            type,
+            loc,
+        };
+    };
+    const result = branch(0, new Set());
+    return { kind: "seqExpr", stmts, result, type: result.type, loc };
+}
 /** 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 pipeline stage taken as a stream under a DynStagePlan: the
+ * checked-dynamic first stage's stream, a value bound before the
+ * branches, or the argument lowered here. */
+function planStreamArg(lowerer, plan, node, i) {
+    if (i === 0 && plan.source !== null)
+        return plan.source.expr;
+    const bound = plan.bound.get(i);
+    return bound !== undefined
+        ? streamArgOf(lowerer, node, bound, "pipeline")
+        : lowerStreamArg(lowerer, node, "pipeline");
+}
 /** 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
@@ -2729,18 +2821,22 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
                 ? pipelineOptions(lowerer, lastArg)
                 : null;
             const stageArgs = opts ? args.slice(0, -1) : args;
-            const build = (src) => lowerPromisePipeline(lowerer, stageArgs, opts, src, loc);
+            const build = (src) => lowerDynStagePipeline(lowerer, stageArgs, src, loc, (plan) => lowerPromisePipeline(lowerer, stageArgs, opts, plan, 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));
+/** stream/promises pipeline(...stages[, options]), for one branch of
+ * lowerDynStagePipeline's plan. */
+function lowerPromisePipeline(lowerer, stageArgs, opts, plan, loc) {
+    const src = plan.source;
+    if (src?.iterable === true ||
+        plan.fns.size > 0 ||
+        plan.preSource !== undefined ||
+        hasPipelineFunctionStage(lowerer, stageArgs)) {
+        const staged = lowerPipelineStages(lowerer, stageArgs, loc, ...stagesSource(src), plan);
         const type = staged.destPromise ?? { kind: "promise", inner: VOID };
         // A promise destination's value settles the result (same type).
         if (!opts) {
@@ -2765,7 +2861,7 @@ function lowerPromisePipeline(lowerer, stageArgs, opts, src, loc) {
     }
     let streams;
     try {
-        streams = stageArgs.map((a, i) => i === 0 && src !== null ? src.expr : lowerStreamArg(lowerer, a, "pipeline"));
+        streams = stageArgs.map((a, i) => planStreamArg(lowerer, plan, a, i));
     }
     catch (e) {
         if (e instanceof StreamArgTypeThrow)
@@ -2917,7 +3013,7 @@ function lowerStreamModuleCallbackCall(lowerer, call, bi, loc) {
         if (args.length < 3) {
             lowerer.noLowering(`pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams, callback)");
         }
-        const build = (src) => lowerCallbackPipeline(lowerer, call, args, src, loc);
+        const build = (src) => lowerDynStagePipeline(lowerer, args.slice(0, -1), src, loc, (plan) => lowerCallbackPipeline(lowerer, call, args, plan, loc));
         return lowerDynSourcePipeline(lowerer, args[0], loc, build) ?? build(null);
     }
     if (bi.member === "compose") {
@@ -2928,16 +3024,23 @@ function lowerStreamModuleCallbackCall(lowerer, call, bi, 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)) {
+/** pipeline(...stages, callback), for one branch of lowerDynStagePipeline's
+ * plan. */
+function lowerCallbackPipeline(lowerer, call, args, plan, loc) {
+    const src = plan.source;
+    const cbNode = args[args.length - 1];
+    const cbParams = ts.isArrowFunction(cbNode) || ts.isFunctionExpression(cbNode)
+        ? cbNode.parameters.nodes.length
+        : 0;
+    // A branch over untyped stages whose destination is a stream: the
+    // callback still receives (err, value), value undefined, as in Node.
+    const dynCallback = plan.bound.size > 0 && cbParams > 1;
+    if (src?.iterable === true ||
+        plan.fns.size > 0 ||
+        plan.preSource !== undefined ||
+        hasPipelineFunctionStage(lowerer, args.slice(0, -1))) {
+        const staged = lowerPipelineStages(lowerer, args.slice(0, -1), loc, ...stagesSource(src), plan);
+        if (staged.dest >= 2 || (staged.dest === 1 && cbParams > 1) || dynCallback) {
             // callback(err, value): the destination's value (undefined for
             // an async generator) reaches the callback through the
             // checked-dynamic path.
@@ -2970,9 +3073,7 @@ function lowerCallbackPipeline(lowerer, call, args, src, loc) {
     }
     let streams;
     try {
-        streams = args
-            .slice(0, -1)
-            .map((a, i) => (i === 0 && src !== null ? src.expr : lowerStreamArg(lowerer, a, "pipeline")));
+        streams = args.slice(0, -1).map((a, i) => planStreamArg(lowerer, plan, a, i));
     }
     catch (e) {
         if (e instanceof StreamArgTypeThrow)
@@ -2980,7 +3081,9 @@ function lowerCallbackPipeline(lowerer, call, args, src, loc) {
         throw e;
     }
     const last = streams[streams.length - 1];
-    const { cb, dyn } = lowerEosCallback(lowerer, "pipeline", args[args.length - 1], last.type);
+    const { cb, dyn } = dynCallback
+        ? { cb: lowerer.lowerExprExpecting(cbNode, DYN), dyn: true }
+        : lowerEosCallback(lowerer, "pipeline", cbNode, last.type);
     return {
         kind: "libCall",
         fn: dyn ? "stream.pipelineDyn" : "stream.pipeline",
@@ -3571,6 +3674,356 @@ function lowerDynIterableSource(lowerer, value, loc) {
         out,
     };
 }
+/** The async generator a checked-dynamic stage's iterable is pumped
+ * through. */
+function dynStageGenType() {
+    return { kind: "generator", async: true, yieldT: DYN, retT: VOID, nextT: UNDEFINED_T };
+}
+/** A checked-dynamic pipeline stage after the first that is a function at
+ * run time, as the stage closure the runtime calls with the previous
+ * stage and { signal } (pipelineImpl's `typeof stream === 'function'`
+ * branch): it calls the function with the previous stream or generator
+ * as an untyped value. Before the last stage the result must be async
+ * iterable (ERR_INVALID_RETURN_VALUE otherwise) and is pumped on through
+ * lowerDynIterableSource's generator; the last stage answers the result,
+ * which the runtime classifies (SCR_PIPE_DEST_DYN). A previous stage
+ * whose type has no untyped form throws the not-supported Error. */
+function lowerDynFunctionStage(lowerer, fnValue, srcT, j, isLast, loc, handoff) {
+    const out = isLast ? DYN : dynStageGenType();
+    const stageT = funcOf([srcT, DYN], out);
+    const take = handoff?.take === true;
+    const give = handoff?.give === true && !isLast;
+    const key = `dynFunctionStage:${isLast ? "dest" : "transform"}:${typeKey(srcT)}:${take ? 1 : 0}${give ? 1 : 0}`;
+    let maker = lowerer.valueHelpers.get(key);
+    if (!maker) {
+        maker = `%stream.dynFunctionStage.${lowerer.valueHelpers.size}`;
+        lowerer.valueHelpers.set(key, maker);
+        const stageName = `${maker}.stage`;
+        const frame = new LiftedFrame(loc);
+        const fnId = frame.local("fn", DYN, false);
+        const labelId = frame.local("label", STRING, false);
+        const cellId = frame.local("cell", DYN, false);
+        const srcId = frame.param("src", srcT);
+        const optsId = frame.param("opts", DYN);
+        const inputId = frame.local("input", DYN, false);
+        const resultId = frame.local("result", DYN, false);
+        const nextId = frame.local("next", DYN, false);
+        const cell = () => varRef(cellId, DYN, loc);
+        const body = [];
+        if (take) {
+            // the previous untyped stage's value, handed over as it is
+            // (makeAsyncIterable answers an iterable itself)
+            body.push({ kind: "varDecl", localId: inputId, init: handoffTake(cell(), loc), loc }, handoffPut(cell(), dynUndefinedExpr(loc), loc));
+        }
+        if (!take && !lowerer.dynConvertible(srcT)) {
+            body.push({
+                kind: "return",
+                value: nodeThrowExpr(0, "SC2020", `pipeline function stages after a stage of type '${lowerer.fmt(srcT)}' are not supported yet`, out, loc),
+                loc,
+            });
+        }
+        else {
+            body.push({
+                kind: "varDecl",
+                localId: resultId,
+                init: {
+                    kind: "dynCall",
+                    callee: varRef(fnId, DYN, loc),
+                    receiver: dynUndefinedExpr(loc),
+                    calleeName: "transform",
+                    args: [
+                        take
+                            ? varRef(inputId, DYN, loc)
+                            : { kind: "dynFrom", value: varRef(srcId, srcT, loc), type: DYN, loc },
+                        varRef(optsId, DYN, loc),
+                    ],
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            });
+            if (isLast) {
+                body.push({ kind: "return", value: varRef(resultId, DYN, loc), loc });
+            }
+            else {
+                body.push({
+                    kind: "varDecl",
+                    localId: nextId,
+                    init: {
+                        kind: "libCall",
+                        fn: "stream.dynTransformResult",
+                        args: [varRef(resultId, DYN, loc), varRef(labelId, STRING, loc)],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                });
+                // the next untyped function stage takes the result itself; the
+                // generator returned for the runtime is then never read
+                if (give)
+                    body.push(handoffPut(cell(), varRef(nextId, DYN, loc), loc));
+                const iterable = lowerDynIterableSource(lowerer, varRef(nextId, DYN, loc), loc);
+                if (!iterable)
+                    throw new InternalCompilerError("dyn iterable generator without a result record");
+                body.push({
+                    kind: "return",
+                    value: { kind: "callValue", callee: iterable.closure, args: [], type: out, loc },
+                    loc,
+                });
+            }
+        }
+        const captured = take || give ? [fnId, labelId, cellId] : [fnId, labelId];
+        for (const id of captured)
+            frame.locals.find((l) => l.id === id).boxed = true;
+        lowerer.liftedFns.push({
+            name: stageName,
+            params: frame.params,
+            returnType: out,
+            captures: [
+                { localId: fnId, name: "fn", type: DYN },
+                { localId: labelId, name: "label", type: STRING },
+                ...(take || give ? [{ localId: cellId, name: "cell", type: DYN }] : []),
+            ],
+            locals: frame.locals,
+            body,
+            loc,
+        });
+        const makerFn = { id: "fn.0", name: "fn", type: DYN, mutable: false, boxed: true };
+        const makerLabel = {
+            id: "label.1",
+            name: "label",
+            type: STRING,
+            mutable: false,
+            boxed: true,
+        };
+        const makerCell = {
+            id: "cell.2",
+            name: "cell",
+            type: DYN,
+            mutable: false,
+            boxed: true,
+        };
+        const makerLocals = take || give ? [makerFn, makerLabel, makerCell] : [makerFn, makerLabel];
+        lowerer.liftedFns.push({
+            name: maker,
+            params: makerLocals.map((l) => ({ localId: l.id, name: l.name, type: l.type })),
+            returnType: stageT,
+            locals: makerLocals,
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "closure",
+                        fnName: stageName,
+                        captures: makerLocals.map((l) => l.id),
+                        type: stageT,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return {
+        closure: {
+            kind: "call",
+            callee: maker,
+            args: [fnValue, strLit(`transform[${j - 1}]`, loc), ...(take || give ? [handoff.cell] : [])],
+            type: stageT,
+            loc,
+        },
+        out,
+    };
+}
+function handoffPut(cell, value, loc) {
+    return {
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "dyn.keySet",
+            args: [cell, strLit("v", loc), value],
+            type: VOID,
+            loc,
+        },
+        loc,
+    };
+}
+function handoffTake(cell, loc) {
+    return { kind: "dynKeyGet", value: cell, key: strLit("v", loc), type: DYN, loc };
+}
+/** `(value) => generator over value`: the async generator an untyped
+ * destination function's async iterable result is pumped through
+ * (SCR_PIPE_DEST_DYN's box), interned. */
+function dynStageIterHelper(lowerer, loc) {
+    const genT = dynStageGenType();
+    const type = funcOf([DYN], genT);
+    const key = "dynStageIter";
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        name = `%stream.dynStageIter.${lowerer.valueHelpers.size}`;
+        lowerer.valueHelpers.set(key, name);
+        const v = { id: "value.0", name: "value", type: DYN, mutable: false };
+        const iterable = lowerDynIterableSource(lowerer, varRef(v.id, DYN, loc), loc);
+        if (!iterable)
+            throw new InternalCompilerError("dyn iterable generator without a result record");
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: v.id, name: v.name, type: DYN }],
+            returnType: genT,
+            locals: [v],
+            body: [
+                {
+                    kind: "return",
+                    value: { kind: "callValue", callee: iterable.closure, args: [], type: genT, loc },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { kind: "closure", fnName: name, captures: [], type, loc };
+}
+/** A checked-dynamic first pipeline stage pumped as an iterable
+ * (pipelineImpl's i === 0 branch), as the stage closure the runtime calls
+ * with { signal } while it sets the pipeline up: a function is called
+ * with { signal } and its result must be iterable, a { readable, writable }
+ * pair pumps its readable side, and any other value is pumped itself,
+ * through lowerDynIterableSource's generator. */
+function lowerDynSourceStage(lowerer, value, loc, cell) {
+    const out = {
+        kind: "generator",
+        async: true,
+        yieldT: DYN,
+        retT: VOID,
+        nextT: UNDEFINED_T,
+    };
+    const stageT = funcOf([DYN], out);
+    const give = cell !== undefined;
+    const key = give ? "dynSourceStage:give" : "dynSourceStage";
+    let maker = lowerer.valueHelpers.get(key);
+    if (!maker) {
+        maker = `%stream.dynSourceStage.${lowerer.valueHelpers.size}`;
+        const stageName = `${maker}.stage`;
+        const frame = new LiftedFrame(loc);
+        const srcId = frame.local("src", DYN, false);
+        const cellId = frame.local("cell", DYN, false);
+        const optsId = frame.param("opts", DYN);
+        const valueId = frame.local("value", DYN, false);
+        const genId = frame.local("gen", out, false);
+        const src = () => varRef(srcId, DYN, loc);
+        const sourceValue = (v, returned) => ({
+            kind: "libCall",
+            fn: "stream.dynSourceValue",
+            args: [v, boolLit(returned, loc)],
+            type: DYN,
+            loc,
+        });
+        const iterable = lowerDynIterableSource(lowerer, varRef(valueId, DYN, loc), loc);
+        if (!iterable)
+            return null;
+        lowerer.valueHelpers.set(key, maker);
+        const body = [
+            {
+                kind: "varDecl",
+                localId: valueId,
+                init: {
+                    kind: "ternary",
+                    cond: { kind: "dynTest", test: "function", value: src(), type: BOOL, loc },
+                    then: sourceValue({
+                        kind: "dynCall",
+                        callee: src(),
+                        receiver: dynUndefinedExpr(loc),
+                        calleeName: "source",
+                        args: [varRef(optsId, DYN, loc)],
+                        type: DYN,
+                        loc,
+                    }, true),
+                    else_: sourceValue(src(), false),
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "varDecl",
+                localId: genId,
+                init: { kind: "callValue", callee: iterable.closure, args: [], type: out, loc },
+                loc,
+            },
+        ];
+        if (give) {
+            // the untyped function stage after the source takes the iterable
+            // itself, as Node's makeAsyncIterable answers it; a stream (a pair's
+            // readable side) goes as the generator over it, as Node iterates a
+            // stream there
+            const v = varRef(valueId, DYN, loc);
+            body.push(handoffPut(varRef(cellId, DYN, loc), {
+                kind: "ternary",
+                cond: { kind: "libCall", fn: "stream.dynIterableSource", args: [v], type: BOOL, loc },
+                then: v,
+                else_: { kind: "dynFrom", value: varRef(genId, out, loc), type: DYN, loc },
+                type: DYN,
+                loc,
+            }, loc));
+        }
+        body.push({ kind: "return", value: varRef(genId, out, loc), loc });
+        const captured = give ? [srcId, cellId] : [srcId];
+        for (const id of captured)
+            frame.locals.find((l) => l.id === id).boxed = true;
+        lowerer.liftedFns.push({
+            name: stageName,
+            params: frame.params,
+            returnType: out,
+            captures: [
+                { localId: srcId, name: "src", type: DYN },
+                ...(give ? [{ localId: cellId, name: "cell", type: DYN }] : []),
+            ],
+            locals: frame.locals,
+            body,
+            loc,
+        });
+        const makerSrc = { id: "src.0", name: "src", type: DYN, mutable: false, boxed: true };
+        const makerCell = {
+            id: "cell.1",
+            name: "cell",
+            type: DYN,
+            mutable: false,
+            boxed: true,
+        };
+        const makerLocals = give ? [makerSrc, makerCell] : [makerSrc];
+        lowerer.liftedFns.push({
+            name: maker,
+            params: makerLocals.map((l) => ({ localId: l.id, name: l.name, type: l.type })),
+            returnType: stageT,
+            locals: makerLocals,
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "closure",
+                        fnName: stageName,
+                        captures: makerLocals.map((l) => l.id),
+                        type: stageT,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return {
+        closure: {
+            kind: "call",
+            callee: maker,
+            args: give ? [value, cell] : [value],
+            type: stageT,
+            loc,
+        },
+        out,
+    };
+}
 function lowerIterableSource(lowerer, node, fn, loc) {
     if (fn === null) {
         const webElem = staticReadableStreamElementType(lowerer, node);
@@ -3700,7 +4153,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, dynSource) {
+function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource, plan) {
     if (stageArgs.length > 52) {
         lowerer.noLowering("pipeline with function stages and more than 52 stages", stageArgs[52], "split the pipeline");
     }
@@ -3718,18 +4171,59 @@ function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource) {
     // before all stages, so when a stage precedes a stream the arguments
     // are bound to locals first, keeping JavaScript's evaluation order.
     const argOrder = [];
+    // An untyped stage followed by an untyped function stage hands its value
+    // over through one cell per call (DynStageHandoff).
+    let handoffCell = null;
+    const cellRef = () => {
+        handoffCell ??= lowerer.declareHiddenLocal("%pipelineHandoff", DYN);
+        return varRef(handoffCell.id, DYN, loc);
+    };
+    let takes = false;
     for (let j = 0; j < stageArgs.length; j++) {
         const arg = stageArgs[j];
+        const givesToNext = plan?.fns.has(j + 1) === true;
         if (j === 0 && dynSource !== undefined) {
-            const source = lowerDynIterableSource(lowerer, dynSource, loc);
+            const source = lowerDynSourceStage(lowerer, dynSource, loc, givesToNext ? cellRef() : undefined);
+            takes = givesToNext;
             if (source === null)
                 lowerer.noLowering("pipeline over this source", arg);
+            // a source function takes { signal }
+            mask |= 1 << stages.length;
             positions += 1;
             argOrder.push({ list: stages, index: stages.length });
             stages.push(source.closure);
             srcT = source.out;
             continue;
         }
+        if (plan?.fns.has(j) === true) {
+            // a checked-dynamic stage that is a function at run time
+            const isLast = j === stageArgs.length - 1;
+            const take = takes;
+            const give = givesToNext && !isLast;
+            takes = give;
+            const lowered = lowerDynFunctionStage(lowerer, plan.bound.get(j), srcT, j, isLast, loc, take || give ? { cell: cellRef(), take, give } : undefined);
+            mask |= 1 << stages.length;
+            positions += 2 ** j;
+            argOrder.push({ list: stages, index: stages.length });
+            stages.push(lowered.closure);
+            if (isLast) {
+                // its result is classified at run time: a promise settles the
+                // pipeline's value, and an async iterable is pumped into the
+                // PassThrough
+                const genT = dynStageGenType();
+                const helpers = fromGenHelpers(lowerer, genT, loc);
+                if (!helpers)
+                    lowerer.noLowering("a pipeline destination with this generator type", arg);
+                helperArgs.push(helpers[0], helpers[1], helpers[2]);
+                dest = 3;
+                destPromise = { kind: "promise", inner: DYN };
+                srcT = null;
+            }
+            else {
+                srcT = lowered.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 &&
@@ -3740,7 +4234,8 @@ function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource) {
         if (j === 0 &&
             !preLowered?.has(j) &&
             (syncSourceFn || (fn === null && iterableSourceType(lowerer, arg) !== null))) {
-            const source = lowerIterableSource(lowerer, arg, syncSourceFn ? fn : null, loc);
+            const source = (syncSourceFn ? undefined : plan?.preSource) ??
+                lowerIterableSource(lowerer, arg, syncSourceFn ? fn : null, loc);
             if (source === null)
                 lowerer.noLowering("pipeline over this source", arg);
             positions += 1;
@@ -3762,7 +4257,12 @@ function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource) {
             }
             let stream;
             try {
-                stream = preLowered?.get(j) ?? lowerStreamArg(lowerer, arg, "pipeline");
+                const bound = plan?.bound.get(j);
+                stream =
+                    preLowered?.get(j) ??
+                        (bound !== undefined
+                            ? streamArgOf(lowerer, arg, bound, "pipeline")
+                            : lowerStreamArg(lowerer, arg, "pipeline"));
             }
             catch (e) {
                 if (e instanceof StreamArgTypeThrow)
@@ -3826,6 +4326,9 @@ function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource) {
         }
         helperArgs.push(pipelineBoxHelper(lowerer, destPromise, loc));
     }
+    else if (dest === 3) {
+        helperArgs.push(dynStageIterHelper(lowerer, loc));
+    }
     const argDecls = [];
     const firstStage = argOrder.findIndex((a) => a.list === stages);
     if (firstStage >= 0 && argOrder.slice(firstStage).some((a) => a.list === streams)) {
@@ -3836,6 +4339,15 @@ function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource) {
             a.list[a.index] = varRef(local.id, init.type, init.loc);
         }
     }
+    if (handoffCell !== null) {
+        const cell = handoffCell;
+        argDecls.unshift({
+            kind: "varDecl",
+            localId: cell.id,
+            init: { kind: "dynObjLit", fields: [], type: DYN, loc },
+            loc,
+        });
+    }
     const bindArgs = (call) => argDecls.length === 0
         ? call
         : { kind: "seqExpr", stmts: argDecls, result: call, type: call.type, loc };
@@ -3877,7 +4389,7 @@ function lowerPipelineStages(lowerer, stageArgs, loc, preLowered, dynSource) {
                 {
                     kind: "varDecl",
                     localId: ac.id,
-                    init: { kind: "libCall", fn: "fetch.abortControllerNew", args: [], type: DYN, loc },
+                    init: { kind: "libCall", fn: "abort.controllerNew", args: [], type: DYN, loc },
                     loc,
                 },
             ],
@@ -4162,7 +4674,7 @@ function duplexFromBody(lowerer, node, loc) {
                 {
                     kind: "varDecl",
                     localId: acLocal.id,
-                    init: { kind: "libCall", fn: "fetch.abortControllerNew", args: [], type: DYN, loc },
+                    init: { kind: "libCall", fn: "abort.controllerNew", args: [], type: DYN, loc },
                     loc,
                 },
             ];
@@ -4544,7 +5056,7 @@ export function operatorSignalOptions(lowerer, options, loc) {
         type: DYN,
         loc,
     };
-    const signal = { kind: "libCall", fn: "fetch.abortAny", args: [list], type: DYN, loc };
+    const signal = { kind: "libCall", fn: "abort.any", args: [list], type: DYN, loc };
     return { kind: "libCall", fn: "readable.opSignalOpts", args: [signal], type: DYN, loc };
 }
 /** reduce's signal for a reducer that reads it (operators.js): `const ac
@@ -4561,7 +5073,7 @@ export function reduceSignalSetup(lowerer, options, loc, declare = (name, type)
         {
             kind: "varDecl",
             localId: acLocal.id,
-            init: { kind: "libCall", fn: "fetch.abortControllerNew", args: [], type: DYN, loc },
+            init: { kind: "libCall", fn: "abort.controllerNew", args: [], type: DYN, loc },
             loc,
         },
         {