@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -1,5 +1,6 @@
+import { keyedHelperName } from "./stable-names.js";
 import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.js";
-import { hashStreamOf, isHashValueType } from "./builtins/hash-stream.js";
+import { isValueStream, valueStreamOf } from "./builtins/hash-stream.js";
 import { InternalCompilerError } from "../../errors.js";
 /* The node:stream lowering (the spoke-module pattern, like
  * lower-event-emitter.ts): construction of the five runtime stream classes
@@ -43,8 +44,12 @@ import { dynUndefinedExpr, varRef } from "../../ir/build.js";
 import { genResultRecord } from "../type-mapper.js";
 import { noteUntypedStreamFlow, requestGeneralStreamSurface } from "./general-streams.js";
 import { dynNativeBranch } from "./dyn-streams.js";
+import { bindingNeverReassigned } from "./binding-analysis.js";
 import { extractIteratorValue, genStep, genValue, stepDrivable } from "./lower-generators.js";
-import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, BYTES_U8, canBoxFuncIntoDyn, canConvertToDyn, funcOf, typeEquals, typeKey, } from "../../ir/ir.js";
+import { LiftedFrame, driveGenerator } from "./containers/iterator-helpers.js";
+import { lowerArrayIteratorValue, lowerStringIteratorValue } from "./iterator-adapters.js";
+import { staticReadableStreamElementType } from "./lower-stdlib.js";
+import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, BYTES_U8, canBoxFuncIntoDyn, canConvertToDyn, funcOf, typeEquals, typeKey, UNDEFINED_T, } from "../../ir/ir.js";
 const BYTES = BYTES_U8;
 /** An expression that only reads bindings and properties (no calls,
  * assignments or construction): reading it a step later observes the
@@ -66,6 +71,55 @@ function pureRead(node) {
     }
     return false;
 }
+/** A literal, `undefined`, or a function expression: a value that reads
+ * no binding or property. */
+function constantOptionValue(node) {
+    let e = node;
+    while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isTypeAssertion(e))
+        e = e.expression;
+    if (ts.isIdentifier(e))
+        return e.text === "undefined";
+    if (ts.isPrefixUnaryExpression(e) &&
+        (e.operator === ts.SyntaxKind.MinusToken ||
+            e.operator === ts.SyntaxKind.PlusToken ||
+            e.operator === ts.SyntaxKind.ExclamationToken))
+        return constantOptionValue(e.operand);
+    return (ts.isStringLiteralLike(e) ||
+        ts.isNumericLiteral(e) ||
+        ts.isBigIntLiteral(e) ||
+        e.kind === ts.SyntaxKind.TrueKeyword ||
+        e.kind === ts.SyntaxKind.FalseKeyword ||
+        e.kind === ts.SyntaxKind.NullKeyword ||
+        ts.isArrowFunction(e) ||
+        ts.isFunctionExpression(e));
+}
+/** Whether a runtime decodeStrings or defaultEncoding value (`prop`'s
+ * `value`) may be read before the other option members. Those values are
+ * read into locals before the constructor evaluates the other members,
+ * while Node evaluates the members in order, so every earlier member must
+ * evaluate without effects, and when the value itself has effects, every
+ * earlier member must also read nothing those effects could change. */
+function earlierOptionsPure(options, prop, value) {
+    const valueHasEffects = !sideEffectFreeOptionValue(value) && !pureRead(value);
+    for (const member of options.properties.nodes) {
+        if (member === prop)
+            return true;
+        if (ts.isPropertyAssignment(member)) {
+            const init = member.initializer;
+            if (valueHasEffects
+                ? !constantOptionValue(init)
+                : !sideEffectFreeOptionValue(init) && !pureRead(init))
+                return false;
+        }
+        else if (ts.isShorthandPropertyAssignment(member)) {
+            if (valueHasEffects)
+                return false;
+        }
+        else if (ts.isSpreadAssignment(member))
+            return false;
+    }
+    return true;
+}
 /** The stream sides of a receiver class: the nearest stream-class
  * ancestor's, or null off the stream hierarchy. */
 export function streamSidesOf(lowerer, info) {
@@ -131,10 +185,23 @@ export const UNDERSCORE_METHODS = new Map([
     ["transform", "_transform"],
     ["flush", "_flush"],
 ]);
+/** The option callbacks applied after construction rather than through
+ * the constructor's callback slots (option name → method name): construct
+ * on every stream class, and writev on every class with a writable side
+ * (a Transform's batches reach writev, not the transform, as in Node). */
+export const STREAM_EXTRA_CALLBACKS = new Map([
+    ["construct", "_construct"],
+    ["writev", "_writev"],
+]);
+export function streamExtraCallbacks(cls) {
+    return cls === "%Readable" ? ["construct"] : ["construct", "writev"];
+}
 /** The completion callback's parameter position in each underscore
  * method that takes one (cbTuples' "fn" positions). */
 export const STREAM_COMPLETION_CALLBACK_INDEX = new Map([
     ["_write", 2],
+    ["_writev", 1],
+    ["_construct", 0],
     ["_final", 0],
     ["_destroy", 1],
     ["_transform", 2],
@@ -229,7 +296,7 @@ export function streamForcedTuple(lowerer, info, name) {
  * (Node calls them stream-bound); arrows keep lexical `this` (the hidden
  * leading param is ABI-only). The declared parameters must be a
  * typeEquals PREFIX of the callback's Node signature. */
-function lowerStreamCallback(lowerer, which, node, thisType, fullTuple) {
+function lowerStreamCallback(lowerer, which, node, thisType, fullTuple, chunkValues = true) {
     const loc = locOf(node);
     const { shapes, funcType } = lowerer.lambdaSignature(node);
     if (node.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
@@ -245,11 +312,26 @@ function lowerStreamCallback(lowerer, which, node, thisType, fullTuple) {
         // callable dyn whose glue dispatches to the runtime's *_done).
         if (funcType.params[i].kind === "dyn")
             continue;
+        // A write or transform chunk of another type converts from the
+        // chunk's value when the callback runs (an object-mode side's value),
+        // or throws a TypeError there — on a side known to be byte mode the
+        // chunk is a Buffer, so the declared type must be Node's or a
+        // supertype of it (`Buffer | string`); an encoding of another type
+        // (`string | null | undefined`) converts from the encoding argument's
+        // value.
+        if (((((i === 0 &&
+            (chunkValues || widensInto(lowerer, fullTuple[0], funcType.params[0], loc))) ||
+            i === 1) &&
+            (which === "write" || which === "transform")) ||
+            (i === 0 && which === "writev")) &&
+            funcType.params[i].kind !== "func" &&
+            canConvertToDyn(funcType.params[i], (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+            continue;
         if (!typeEquals(funcType.params[i], fullTuple[i])) {
             lowerer.noLowering(`a '${which}' callback whose parameter ${i} is '${lowerer.fmt(funcType.params[i])}' where Node passes '${lowerer.fmt(fullTuple[i])}'`, node, "annotate the parameter with the Node signature's type (chunks are Buffers here)");
         }
     }
-    const fnName = `%fn${lowerer.lambdaCounter++}_${which}cb`;
+    const fnName = lowerer.closureName(loc, `_${which}cb`);
     const fnCtx = newFnCtx(true, null, funcType, funcType.ret);
     lowerer.fnStack.push(fnCtx);
     try {
@@ -311,6 +393,58 @@ function lowerStreamCallback(lowerer, which, node, thisType, fullTuple) {
         lowerer.fnStack.pop();
     }
 }
+/** The objectMode, readableObjectMode and writableObjectMode members of a
+ * stream options literal (boolean literals; the sided keys count only on
+ * a Duplex, Transform or PassThrough, as in Node). */
+function streamObjectModes(lowerer, ctorName, optsLit) {
+    const out = { readable: false, writable: false };
+    const duplexish = ctorName !== "Readable" && ctorName !== "Writable";
+    for (const prop of optsLit?.properties?.nodes ?? []) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ? prop.name.text : null;
+        if (name !== "objectMode" && name !== "readableObjectMode" && name !== "writableObjectMode")
+            continue;
+        const value = prop.initializer;
+        if (value.kind === ts.SyntaxKind.FalseKeyword)
+            continue;
+        if (value.kind !== ts.SyntaxKind.TrueKeyword) {
+            lowerer.noLowering(`${ctorName} with a runtime '${name}' value`, prop, `write '${name}: true' or '${name}: false'`);
+        }
+        if (name === "objectMode") {
+            out.readable = true;
+            out.writable = true;
+        }
+        else if (duplexish) {
+            if (name === "readableObjectMode")
+                out.readable = true;
+            else
+                out.writable = true;
+        }
+    }
+    return out;
+}
+/** Whether an options literal makes the writable side hold values: its
+ * object mode set with a `true` literal (objectMode, or writableObjectMode
+ * on a duplex stream), or decodeStrings: false (strings stay strings).
+ * Reports nothing: the options parse fences the other value forms. */
+function literalWritesValues(opts, duplexish) {
+    for (const prop of opts.properties?.nodes ?? []) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ? prop.name.text : null;
+        if (name === "decodeStrings") {
+            if (prop.initializer.kind !== ts.SyntaxKind.TrueKeyword)
+                return true;
+            continue;
+        }
+        if (name !== "objectMode" && !(duplexish && name === "writableObjectMode"))
+            continue;
+        if (prop.initializer.kind !== ts.SyntaxKind.FalseKeyword)
+            return true;
+    }
+    return false;
+}
 /** The full Node parameter tuples of the option callbacks, given the
  * concrete stream's `this` type. The trailing completion callbacks keep
  * whatever func type the checker contextually gave the user's parameter
@@ -321,6 +455,8 @@ function cbTuples(lowerer) {
         read: [F64],
         write: [BYTES, STRING, "fn"],
         final: ["fn"],
+        construct: ["fn"],
+        writev: [DYN, "fn"],
         destroy: [errorOrNull(lowerer), "fn"],
         transform: [BYTES, STRING, "fn"],
         flush: ["fn"],
@@ -514,10 +650,57 @@ function pinAnyDataCompletion(lowerer, which, fnNode) {
     const declared = lowerer.paramShape(param).type;
     if (declared.kind !== "func" || declared.rest || declared.params[1]?.kind !== "dyn")
         return null;
+    // Only when every use calls the callback with a Buffer, a string or
+    // nothing as `data`: another value (or a callback that escapes) keeps
+    // `data` checked-dynamic, so the runtime pushes it as push(data) does
+    // and reports ERR_INVALID_ARG_TYPE through 'error', as Node does.
+    if (fnNode.body === undefined || !completionDataIsChunk(lowerer, fnNode.body, symbol, param.name))
+        return null;
     const data = unionOf(lowerer, [BYTES, STRING, { kind: "undefinedT" }]);
     lowerer.stageSourceTypes.set(symbol, funcOf([declared.params[0], data, ...declared.params.slice(2)], declared.ret));
     return symbol;
 }
+/** Whether every reference to the completion callback `symbol` in `body`
+ * calls it with a `data` argument that is a Buffer, a string, null or
+ * undefined (or with no data). */
+function completionDataIsChunk(lowerer, body, symbol, declaration) {
+    let ok = true;
+    const visit = (node) => {
+        if (!ok)
+            return;
+        if (ts.isIdentifier(node) &&
+            node !== declaration &&
+            lowerer.checker.getSymbolAtLocation(node) === symbol) {
+            const call = node.parent;
+            if (!call || !ts.isCallExpression(call) || call.expression !== node) {
+                ok = false;
+                return;
+            }
+            const data = call.arguments.nodes[1];
+            if (data !== undefined) {
+                let t;
+                try {
+                    t = lowerer.mapTypeOf(lowerer.typeOf(data));
+                }
+                catch {
+                    t = null;
+                }
+                const arms = t?.kind === "union" ? (lowerer.unions.get(t.unionId)?.arms ?? null) : t ? [t] : null;
+                if (arms === null ||
+                    !arms.every((a) => (a.kind === "bytes" && a.elem === "u8") ||
+                        a.kind === "string" ||
+                        a.kind === "undefinedT" ||
+                        a.kind === "nullT")) {
+                    ok = false;
+                    return;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(body);
+    return ok;
+}
 /** Parses the options object literal of a stream constructor. `which`
  * names the callbacks this class accepts, in canonical flag order. */
 function parseStreamOptions(lowerer, ctorName, arg, thisType, accepted, loc, 
@@ -538,14 +721,50 @@ fallbackCb) {
         badEncoding: null,
         pushEncoding: null,
         signal: null,
+        valueDecls: [],
+        decodeStringsValue: null,
+        defaultEncodingValue: null,
+        readableObject: false,
+        writableObject: false,
+        decodeStringsOff: false,
+        writeEncoding: null,
+        extras: [],
         flags: 0,
         cbs: [],
     };
+    const extraNames = streamExtraCallbacks(`%${ctorName}`);
+    const writableClass = ctorName !== "Readable";
     const followed = followOptionsArg(lowerer, arg);
     const optsLit = followed === null ? undefined : followed;
     if (optsLit !== undefined && !ts.isObjectLiteralExpression(optsLit)) {
         lowerer.noLowering(`new ${ctorName} with a non-literal options argument`, optsLit, "the options must be an object literal, inline or through const-initialized bindings (the callbacks lower as compile-time closures)");
     }
+    // Read before the callbacks lower: an object-mode readable side keeps a
+    // completion callback's `data: any` (its values are not only strings and
+    // Buffers). An object-mode side's high-water mark defaults to 16.
+    const objectModes = streamObjectModes(lowerer, ctorName, optsLit !== undefined && ts.isObjectLiteralExpression(optsLit) ? optsLit : undefined);
+    out.readableObject = objectModes.readable;
+    out.writableObject = objectModes.writable;
+    // the chunk an option callback receives can be another value than a
+    // Buffer (literalWritesValues), read before any callback lowers
+    const writesValues = optsLit !== undefined &&
+        ts.isObjectLiteralExpression(optsLit) &&
+        literalWritesValues(optsLit, ctorName !== "Readable" && ctorName !== "Writable");
+    // In JavaScript a decodeStrings value known only at run time may let
+    // string writes through, so the write and transform callbacks' chunk
+    // parameters read as any (the declarations type it Buffer).
+    const runtimeDecodeStrings = optsLit !== undefined &&
+        isJsSourceFile(ts.getSourceFileOfNode(optsLit)) &&
+        ts.isObjectLiteralExpression(optsLit) &&
+        (optsLit.properties?.nodes ?? []).some((p) => ts.isPropertyAssignment(p) &&
+            (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
+            p.name.text === "decodeStrings" &&
+            p.initializer.kind !== ts.SyntaxKind.TrueKeyword &&
+            p.initializer.kind !== ts.SyntaxKind.FalseKeyword);
+    if (out.readableObject)
+        out.hwmR = numLit(16, loc);
+    if (out.writableObject)
+        out.hwmW = numLit(16, loc);
     const tuples = cbTuples(lowerer);
     const present = new Map();
     for (const prop of optsLit?.properties?.nodes ?? []) {
@@ -559,7 +778,7 @@ fallbackCb) {
             lowerer.unsupported("SC1090", prop, `computed or spread members in ${ctorName} options`);
         }
         // Callback members: shorthand methods and function-valued properties.
-        if (accepted.includes(name)) {
+        if (accepted.includes(name) || extraNames.includes(name)) {
             let fnNode = null;
             if (ts.isMethodDeclaration(prop))
                 fnNode = prop;
@@ -583,7 +802,8 @@ fallbackCb) {
                 continue;
             }
             const full = tuples[name].map((t) => (t === "fn" ? null : t));
-            const pinned = pinAnyDataCompletion(lowerer, name, fnNode);
+            const pinned = out.readableObject ? null : pinAnyDataCompletion(lowerer, name, fnNode);
+            let anyChunk;
             try {
                 // The completion-callback tail: typed by the checker contextually;
                 // accept the user's declared func type as the tuple's entry so the
@@ -598,11 +818,22 @@ fallbackCb) {
                     }
                     return declared ?? funcOf([], VOID);
                 });
-                present.set(name, lowerStreamCallback(lowerer, name, fnNode, thisType, tuple));
+                const chunkParam = runtimeDecodeStrings && (name === "write" || name === "transform")
+                    ? fnNode.parameters.nodes[0]
+                    : undefined;
+                anyChunk =
+                    chunkParam !== undefined && ts.isIdentifier(chunkParam.name) && !chunkParam.type
+                        ? lowerer.checker.getSymbolAtLocation(chunkParam.name)
+                        : undefined;
+                if (anyChunk)
+                    lowerer.anySymbols.add(anyChunk);
+                present.set(name, lowerStreamCallback(lowerer, name, fnNode, thisType, tuple, writesValues));
             }
             finally {
                 if (pinned)
                     lowerer.stageSourceTypes.delete(pinned);
+                if (anyChunk)
+                    lowerer.anySymbols.delete(anyChunk);
             }
             continue;
         }
@@ -641,17 +872,33 @@ fallbackCb) {
                 break;
             case "objectMode":
             case "readableObjectMode":
-            case "writableObjectMode": {
-                // `objectMode: false` is the byte default — admit the literal.
-                if (value.kind === ts.SyntaxKind.FalseKeyword)
-                    break;
-                lowerer.noLowering(`${ctorName} in objectMode`, prop, "object-mode streams have no static chunk type yet — chunks are Buffers (utf8 strings convert at push/write)");
+            case "writableObjectMode":
+                // read up front (streamObjectModes)
                 break;
-            }
             case "decodeStrings": {
+                // WritableState's `options.decodeStrings === false`; a Readable
+                // ignores the option
                 if (value.kind === ts.SyntaxKind.TrueKeyword)
                     break; // Node's default
-                lowerer.noLowering(`${ctorName} with decodeStrings: false`, prop, "chunks always decode to Buffers here (Node's default)");
+                if (value.kind === ts.SyntaxKind.FalseKeyword) {
+                    if (writableClass)
+                        out.decodeStringsOff = true;
+                    break;
+                }
+                // a runtime value: WritableState's `options.decodeStrings !== false`
+                if (optsLit !== undefined &&
+                    ts.isObjectLiteralExpression(optsLit) &&
+                    !earlierOptionsPure(optsLit, prop, value))
+                    lowerer.noLowering(`the ${ctorName} option 'decodeStrings' with a runtime value that an earlier option value could observe or change`, prop, "compute the option values into consts before the options object (the runtime value is read before the other options run)");
+                const local = lowerer.declareHiddenLocal("%decodeStrings", DYN);
+                out.valueDecls.push({
+                    kind: "varDecl",
+                    localId: local.id,
+                    init: lowerer.lowerExprExpecting(value, DYN),
+                    loc,
+                });
+                if (writableClass)
+                    out.decodeStringsValue = varRef(local.id, DYN, loc);
                 break;
             }
             case "encoding": {
@@ -687,12 +934,45 @@ fallbackCb) {
                         out.badEncoding = t.value;
                         break;
                     }
-                    if (t.isStringLiteralType() && ctorName === "Readable") {
-                        out.pushEncoding = knownBufEncoding(t.value);
+                    if (t.isStringLiteralType()) {
+                        // the readable side decodes push(string) with it, and the
+                        // writable side encodes write(string) with it (the name as
+                        // written reaches _write when decodeStrings is false)
+                        if (ctorName !== "Writable" && !out.readableObject)
+                            out.pushEncoding = knownBufEncoding(t.value);
+                        if (writableClass)
+                            out.writeEncoding = t.value;
                         break;
                     }
                 }
-                lowerer.noLowering(`the ${ctorName} option 'defaultEncoding'`, prop, "utf8 (the default) is the supported write-side string encoding");
+                {
+                    // a runtime value: null, undefined and utf8 are the default,
+                    // another name Buffer.isEncoding knows is kept as given, and any
+                    // other value throws ERR_UNKNOWN_ENCODING before construction
+                    if (optsLit !== undefined &&
+                        ts.isObjectLiteralExpression(optsLit) &&
+                        !earlierOptionsPure(optsLit, prop, value))
+                        lowerer.noLowering(`the ${ctorName} option 'defaultEncoding' with a runtime value that an earlier option value could observe or change`, prop, "compute the option values into consts before the options object (the runtime value is read before the other options run)");
+                    const local = lowerer.declareHiddenLocal("%defaultEncoding", DYN);
+                    const ref = varRef(local.id, DYN, loc);
+                    out.valueDecls.push({
+                        kind: "varDecl",
+                        localId: local.id,
+                        init: lowerer.lowerExprExpecting(value, DYN),
+                        loc,
+                    }, {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "libCall",
+                            fn: "stream.checkEncodingOption",
+                            args: [ref],
+                            type: VOID,
+                            loc,
+                        },
+                        loc,
+                    });
+                    out.defaultEncodingValue = ref;
+                }
                 break;
             case "signal": {
                 // `if (options.signal) addAbortSignal(options.signal, this)`:
@@ -742,11 +1022,8 @@ fallbackCb) {
                     : "the final callback is supported on Writable and Duplex");
                 break;
             }
-            case "construct":
-                lowerer.noLowering(`the ${ctorName} option 'construct'`, prop, "deferred construction (_construct) is not lowered yet");
-                break;
             case "writev":
-                lowerer.noLowering(`the ${ctorName} option 'writev'`, prop, "batched writes (_writev) are not lowered yet — writes deliver one chunk at a time");
+                lowerer.noLowering(`the ${ctorName} option 'writev'`, prop, "a Readable has no writable side");
                 break;
             default:
                 lowerer.noLowering(`the ${ctorName} option '${name}'`, prop);
@@ -762,6 +1039,11 @@ fallbackCb) {
             out.cbs.push(cb);
         }
     }
+    for (const name of extraNames) {
+        const cb = present.get(name) ?? fallbackCb?.(name) ?? null;
+        if (cb)
+            out.extras.push({ name, cb });
+    }
     return out;
 }
 /** The head + flags argument list of a stream construction/initialization
@@ -788,8 +1070,66 @@ function streamCtorArgs(lowerer, cls, arg, thisType, loc, fallbackCb) {
         badEncoding: o.badEncoding,
         pushEncoding: o.pushEncoding,
         signal: o.signal,
+        valueDecls: o.valueDecls,
+        decodeStringsValue: o.decodeStringsValue,
+        defaultEncodingValue: o.defaultEncodingValue,
+        readableObject: o.readableObject,
+        writableObject: o.writableObject,
+        decodeStringsOff: o.decodeStringsOff,
+        writeEncoding: o.writeEncoding,
+        extras: o.extras,
     };
 }
+/** The follow-ups a stream's options apply over the fresh stream `recv`
+ * after the chained ones: decodeStrings, the writable defaultEncoding,
+ * then writev and construct (Node's constructors schedule construct
+ * last). */
+function streamOptionFollowUps(parsed, recv, thisType, loc, writevFn = "stream.setWritev") {
+    const out = [];
+    if (parsed.decodeStringsOff) {
+        out.push({
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "stream.decodeStrings",
+                args: [recv(), boolLit(false, loc)],
+                type: thisType,
+                loc,
+            },
+            loc,
+        });
+    }
+    if (parsed.writeEncoding !== null) {
+        out.push({
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "writable.writeEncoding",
+                args: [recv(), strLit(parsed.writeEncoding, loc)],
+                type: thisType,
+                loc,
+            },
+            loc,
+        });
+    }
+    for (const name of ["writev", "construct"]) {
+        const extra = parsed.extras.find((x) => x.name === name);
+        if (!extra)
+            continue;
+        out.push({
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: name === "writev" ? writevFn : "stream.setConstruct",
+                args: [recv(), extra.cb],
+                type: VOID,
+                loc,
+            },
+            loc,
+        });
+    }
+    return out;
+}
 /** `new Readable(opts?)` and friends — called from lowerNew once the
  * callee resolved to a builtin stream class. */
 export function lowerStreamNew(lowerer, expr, info) {
@@ -822,6 +1162,29 @@ export function lowerStreamNew(lowerer, expr, info) {
         return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", `Unknown encoding: ${parsed.badEncoding}`, thisType, loc);
     }
     let built = { kind: "libCall", fn, args: parsed.args, type: thisType, loc };
+    if (parsed.readableObject || parsed.writableObject) {
+        // { objectMode }: applied before any other follow-up (answers the
+        // receiver +1).
+        built = {
+            kind: "libCall",
+            fn: "stream.objectMode",
+            args: [built, boolLit(parsed.readableObject, loc), boolLit(parsed.writableObject, loc)],
+            type: thisType,
+            loc,
+        };
+    }
+    const values = optionValuesArgs(parsed, loc);
+    if (values) {
+        // runtime decodeStrings and defaultEncoding values (answers the
+        // receiver +1)
+        built = {
+            kind: "libCall",
+            fn: "stream.optionValues",
+            args: [built, ...values],
+            type: thisType,
+            loc,
+        };
+    }
     if (parsed.pushEncoding !== null) {
         // { defaultEncoding }: chain the push-side decode default (the
         // setEncoding chaining shape — answers the receiver +1).
@@ -844,17 +1207,45 @@ export function lowerStreamNew(lowerer, expr, info) {
             loc,
         };
     }
-    if (parsed.signal === null)
-        return built;
-    // { signal }: addAbortSignal over the fresh stream (answers it +1).
+    if (parsed.signal !== null) {
+        // { signal }: addAbortSignal over the fresh stream (answers it +1).
+        built = {
+            kind: "libCall",
+            fn: "stream.addAbortSignal",
+            args: [built, parsed.signal],
+            type: thisType,
+            loc,
+        };
+    }
+    if (!parsed.decodeStringsOff && parsed.writeEncoding === null && parsed.extras.length === 0) {
+        return parsed.valueDecls.length > 0
+            ? { kind: "seqExpr", stmts: parsed.valueDecls, result: built, type: thisType, loc }
+            : built;
+    }
+    const fresh = lowerer.declareHiddenLocal("%stream", thisType);
+    const followUps = streamOptionFollowUps(parsed, () => varRef(fresh.id, thisType, loc), thisType, loc);
     return {
-        kind: "libCall",
-        fn: "stream.addAbortSignal",
-        args: [built, parsed.signal],
+        kind: "seqExpr",
+        stmts: [
+            ...parsed.valueDecls,
+            { kind: "varDecl", localId: fresh.id, init: built, loc },
+            ...followUps,
+        ],
+        result: varRef(fresh.id, thisType, loc),
         type: thisType,
         loc,
     };
 }
+/** stream.optionValues' (decodeStrings, defaultEncoding) arguments, or
+ * null when both options are literals or absent. */
+function optionValuesArgs(parsed, loc) {
+    if (parsed.decodeStringsValue === null && parsed.defaultEncodingValue === null)
+        return null;
+    return [
+        parsed.decodeStringsValue ?? dynUndefinedExpr(loc),
+        parsed.defaultEncodingValue ?? dynUndefinedExpr(loc),
+    ];
+}
 /** True when a value of Node's argument type `passed` widens implicitly
  * into the declared parameter type `declared` (one of its union arms, or a
  * sub-union of it). */
@@ -871,7 +1262,7 @@ function widensInto(lowerer, passed, declared, loc) {
  * overrides it (the ordinary devirtualization rule), so an inherited
  * constructor still binds the DYNAMIC class's override. The method may
  * declare any PREFIX of its Node signature (the option-callback rule). */
-function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, blame) {
+function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, blame, chunkValues = true) {
     const found = lowerer.findMethodOn(info, methodName);
     if (!found) {
         // A DESCENDANT-only declaration (the base chain never declares it):
@@ -914,6 +1305,18 @@ function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, bl
             }
         }
         else if (!typeEquals(got.type, want)) {
+            // A write or transform encoding of another type (`string | null |
+            // undefined`) converts from the encoding argument's value: an
+            // object-mode write passes undefined, null or the name. A chunk of
+            // another type (`string | Buffer` under decodeStrings: false)
+            // converts from the chunk's value.
+            if ((i === 1 || (i === 0 && (chunkValues || which === "writev"))) &&
+                (which === "write" || which === "transform" || which === "writev") &&
+                got.type.kind !== "func" &&
+                canConvertToDyn(got.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                paramTypes.push(got.type);
+                continue;
+            }
             // A declared supertype of what Node passes (`chunk: Buffer | string`)
             // is sound: the wrapper takes Node's value and widens it into the
             // declared parameter.
@@ -921,12 +1324,22 @@ function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, bl
                 paramTypes.push(want);
                 continue;
             }
+            // A write or transform chunk of another type converts from the
+            // chunk's value when the method runs (an object-mode side's value),
+            // or throws a TypeError there; a byte-mode side's chunk is a Buffer.
+            if (i === 0 &&
+                (which === "writev" || (chunkValues && (which === "write" || which === "transform"))) &&
+                got.type.kind !== "func" &&
+                canConvertToDyn(got.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                paramTypes.push(got.type);
+                continue;
+            }
             lowerer.noLowering(`a '${methodName}' method whose parameter ${i} is '${lowerer.fmt(got.type)}' where Node passes '${lowerer.fmt(want)}'`, blame, "annotate the parameter with the Node signature's type or a supertype of it (chunks are Buffers here)");
         }
         paramTypes.push(got.type);
     }
     const ret = found.sig.ret;
-    const fnName = `%fn${lowerer.lambdaCounter++}_${which}vt`;
+    const fnName = lowerer.closureName(loc, `_${which}vt`);
     const funcType = funcOf([thisType, ...paramTypes], ret);
     lowerer.fnStack.push(newFnCtx(true, null, funcType, ret));
     try {
@@ -996,10 +1409,21 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
         lowerer.noLowering(`super(...) with ${argNodes.length} arguments in a ${cls.slice(1)} subclass`, blame, "the supported form takes one inline options object (or none)");
     }
     const shape = streamCtorShape(cls);
+    // Whether the writable side holds values: options read at run time may
+    // set objectMode, and a literal says so with objectMode (or a Duplex's
+    // writableObjectMode) true; otherwise _write and _transform receive
+    // Buffers.
+    // super(undefined) and super(null) pass no options (followOptionsArg
+    // answers null), so their sides are byte mode too.
+    const optsNode = argNodes[0] !== undefined ? followOptionsArg(lowerer, argNodes[0]) : null;
+    const chunkValues = optsNode !== null &&
+        optsNode !== undefined &&
+        (!ts.isObjectLiteralExpression(optsNode) ||
+            literalWritesValues(optsNode, cls !== "%Readable" && cls !== "%Writable"));
     const fallback = (name) => {
-        const methodName = UNDERSCORE_METHODS.get(name);
+        const methodName = UNDERSCORE_METHODS.get(name) ?? STREAM_EXTRA_CALLBACKS.get(name);
         return methodName
-            ? streamMethodWrapper(lowerer, info, name, methodName, thisType, loc, blame)
+            ? streamMethodWrapper(lowerer, info, name, methodName, thisType, loc, blame, chunkValues)
             : null;
     };
     const thisRef = () => ({ kind: "varRef", localId: thisLocal.id, type: thisType, loc });
@@ -1018,6 +1442,14 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
                     cbs.push(cb);
                 }
             }
+            // The class's _writev and _construct ride the same way: an options
+            // writev or construct (applied by initDyn) wins.
+            const extras = [];
+            for (const name of streamExtraCallbacks(cls)) {
+                const cb = fallback(name);
+                if (cb)
+                    extras.push({ name, cb });
+            }
             return [
                 {
                     kind: "exprStmt",
@@ -1030,6 +1462,7 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
                     },
                     loc,
                 },
+                ...streamOptionFollowUps({ decodeStringsOff: false, writeEncoding: null, extras }, thisRef, thisType, loc, "stream.setWritevDefault"),
             ];
         }
     }
@@ -1046,6 +1479,7 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
         ];
     }
     const out = [
+        ...parsed.valueDecls,
         {
             kind: "exprStmt",
             expr: {
@@ -1058,6 +1492,33 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
             loc,
         },
     ];
+    if (parsed.readableObject || parsed.writableObject) {
+        out.push({
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "stream.objectMode",
+                args: [thisRef(), boolLit(parsed.readableObject, loc), boolLit(parsed.writableObject, loc)],
+                type: thisType,
+                loc,
+            },
+            loc,
+        });
+    }
+    const values = optionValuesArgs(parsed, loc);
+    if (values) {
+        out.push({
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "stream.optionValues",
+                args: [thisRef(), ...values],
+                type: thisType,
+                loc,
+            },
+            loc,
+        });
+    }
     if (parsed.pushEncoding !== null) {
         out.push({
             kind: "exprStmt",
@@ -1097,6 +1558,7 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
             loc,
         });
     }
+    out.push(...streamOptionFollowUps(parsed, thisRef, thisType, loc));
     return out;
 }
 /* ── the underscore-method assignment surface ─────────────────────────── */
@@ -1140,14 +1602,16 @@ export function lowerStreamUnderscoreAssign(lowerer, expr) {
     const loc = locOf(expr);
     const cls = base.def.name;
     const clsName = cls.slice(1);
-    if (methodName === "_writev" || methodName === "_construct") {
-        lowerer.noLowering(`assigning '${methodName}' on a ${clsName}`, expr.left, methodName === "_writev"
-            ? "batched writes (_writev) are not lowered yet — writes deliver one chunk at a time"
-            : "deferred construction (_construct) is not lowered yet");
-    }
-    const which = optionByMethod.get(methodName);
+    // `_construct`: Node's constructNT reads it on the construction tick, so
+    // an assignment before that tick replaces a scheduled hook
+    // (stream.replaceConstruct) and has no effect after it or without one.
+    const which = methodName === "_writev"
+        ? "writev"
+        : methodName === "_construct"
+            ? "construct"
+            : optionByMethod.get(methodName);
     const { accepted } = streamCtorShape(cls);
-    if (!accepted.includes(which)) {
+    if (!accepted.includes(which) && !streamExtraCallbacks(cls).includes(which)) {
         lowerer.noLowering(`assigning '${methodName}' on a ${clsName}`, expr.left, `a ${clsName}'s machinery consumes ${accepted.map((a) => `'${UNDERSCORE_METHODS.get(a)}'`).join("/")} — '${methodName}' would ride machinery with no lowering here`);
     }
     const thisType = recv.type;
@@ -1178,6 +1642,8 @@ export function lowerStreamUnderscoreAssign(lowerer, expr) {
         destroy: "stream.setDestroy",
         transform: "stream.setTransform",
         flush: "stream.setFlush",
+        writev: "stream.setWritev",
+        construct: "stream.replaceConstruct",
     };
     return {
         kind: "exprStmt",
@@ -1235,25 +1701,165 @@ export function lowerStreamStaticCall(lowerer, call, access) {
             }
         }
     }
+    if (member === "fromWeb" && cls === "%Readable")
+        return lowerReadableFromWeb(lowerer, call, loc);
     if (member !== "from") {
         lowerer.noLowering(`${cls.slice(1)}.${member}`, call);
     }
+    if (cls === "%Duplex") {
+        const fromArgs = call.arguments.nodes;
+        if (fromArgs.length !== 1) {
+            lowerer.noLowering(`Duplex.from with ${fromArgs.length} arguments`, call, "Duplex.from takes one body");
+        }
+        return duplexFromBody(lowerer, fromArgs[0], locOf(call));
+    }
     if (cls !== "%Readable") {
-        lowerer.noLowering(`${cls.slice(1)}.from`, call, "Readable.from is the lowered form");
+        lowerer.noLowering(`${cls.slice(1)}.from`, call, "Readable.from and Duplex.from are the lowered forms");
     }
     const args = call.arguments.nodes;
     if (args.length > 2) {
         lowerer.noLowering(`Readable.from with ${args.length} arguments`, call, "Readable.from(iterable, options) is the supported form");
     }
-    const type = { kind: "object", className: "%Readable" };
+    return lowerFromSource(lowerer, call, args[0], args[1], false);
+}
+/** Readable.fromWeb(readableStream, options): Node's adapter over the web
+ * stream's reader (scr_stream_from_web.c). The options are an object
+ * literal: objectMode a boolean literal, highWaterMark a number, encoding
+ * a literal name, and signal a variable or property read, applied with
+ * addAbortSignal as the constructors do. */
+function lowerReadableFromWeb(lowerer, call, loc) {
+    const args = call.arguments.nodes;
+    const readable = { kind: "object", className: "%Readable" };
+    if (args.length === 0 || args.length > 2 || args.some((a) => ts.isSpreadElement(a))) {
+        lowerer.noLowering(`Readable.fromWeb with ${args.length} arguments`, call, "the supported form is Readable.fromWeb(readableStream, options)");
+    }
+    const web = lowerer.lowerExprExpecting(args[0], DYN);
+    let objectMode = false;
+    let hwm = numLit(-1, loc);
+    let encoding = "";
+    let signal = null;
+    const options = args[1];
+    if (options !== undefined) {
+        if (!ts.isObjectLiteralExpression(options)) {
+            lowerer.noLowering("Readable.fromWeb options that are not an object literal", options, "pass { objectMode, highWaterMark, encoding, signal } as an object literal");
+        }
+        for (const p of options.properties.nodes) {
+            const key = (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+                ts.isIdentifier(p.name)
+                ? p.name.text
+                : null;
+            const value = key === null
+                ? null
+                : ts.isShorthandPropertyAssignment(p)
+                    ? p.name
+                    : p.initializer;
+            if (key === "objectMode" && value) {
+                if (value.kind === ts.SyntaxKind.TrueKeyword)
+                    objectMode = true;
+                else if (value.kind !== ts.SyntaxKind.FalseKeyword)
+                    lowerer.noLowering("the Readable.fromWeb option 'objectMode' with this value", p, "write true or false");
+                continue;
+            }
+            if (key === "highWaterMark" && value) {
+                hwm = lowerer.lowerExprExpecting(value, F64);
+                continue;
+            }
+            if (key === "encoding" && value) {
+                const t = lowerer.typeOf(value);
+                if (t.isStringLiteralType() && knownBufEncoding(t.value) === undefined) {
+                    return nodeThrowExpr(1, "ERR_INVALID_ARG_VALUE", `The property 'options.encoding' is invalid. Received '${t.value}'`, readable, loc);
+                }
+                encoding = bufEncoding(lowerer, "the Readable.fromWeb option 'encoding'", value);
+                continue;
+            }
+            if (key === "signal" && value) {
+                if (!sideEffectFreeOptionValue(value) && !pureRead(value)) {
+                    lowerer.noLowering("the Readable.fromWeb option 'signal' with this value", p, "pass a variable or property read (const signal = controller.signal)");
+                }
+                signal = lowerer.lowerExprExpecting(value, DYN);
+                continue;
+            }
+            lowerer.noLowering(key === null
+                ? "Readable.fromWeb options with this member"
+                : `the Readable.fromWeb option '${key}'`, p, "objectMode, highWaterMark, encoding and signal are the Readable.fromWeb options");
+        }
+    }
+    const built = {
+        kind: "libCall",
+        fn: "fetch.readableFromWeb",
+        args: [web, boolLit(objectMode, loc), hwm, strLit(encoding, loc)],
+        type: readable,
+        loc,
+    };
+    if (signal === null)
+        return built;
+    return {
+        kind: "libCall",
+        fn: "stream.addAbortSignal",
+        args: [built, signal],
+        type: readable,
+        loc,
+    };
+}
+/** Readable.from(source, options), and for Duplex.from over an iterable
+ * (duplex) duplexify.js's from(Duplexify, body, { objectMode: true,
+ * writable: false }): the same builders with SCR_FROM_DUPLEX, answering a
+ * Duplexify without a writable side. */
+function lowerFromSource(lowerer, at, srcNode, optsNode, duplex) {
+    const loc = locOf(at);
+    const call = at;
+    const type = { kind: "object", className: duplex ? "%Duplex" : "%Readable" };
+    const what = duplex ? "Duplex.from" : "Readable.from";
+    // SCR_FROM_DUPLEX
+    const duplexFlag = duplex ? 32 : 0;
     const js = isJsSourceFile(ts.getSourceFileOfNode(call));
-    const srcNode = args[0];
-    const optsNode = args[1];
+    // A web ReadableStream is async iterable: from.js reads its iterator.
+    // Duplex.from takes _duplexify({ readable: Readable.fromWeb(body) }).
+    const webElem = srcNode ? staticReadableStreamElementType(lowerer, srcNode) : null;
+    if (srcNode && webElem !== null && duplex) {
+        const fromWeb = {
+            kind: "libCall",
+            fn: "fetch.readableFromWeb",
+            args: [
+                lowerer.lowerExprExpecting(srcNode, DYN),
+                boolLit(false, loc),
+                numLit(-1, loc),
+                strLit("", loc),
+            ],
+            type: { kind: "object", className: "%Readable" },
+            loc,
+        };
+        return { kind: "libCall", fn: "stream.duplexifyReadable", args: [fromWeb], type, loc };
+    }
+    if (srcNode && webElem !== null) {
+        const source = lowerWebStreamSource(lowerer, srcNode, webElem, loc);
+        const helpers = source ? fromGenHelpers(lowerer, source.out, loc) : null;
+        const opts = optsNode ? fromOptions(lowerer, optsNode) : { flags: 0, hwm: null };
+        if (!source || !helpers || !opts || !fromGenChunk(lowerer, webElem)) {
+            lowerer.noLowering(`Readable.from over a web ReadableStream of '${lowerer.fmt(webElem)}'`, srcNode);
+        }
+        const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
+        const gen = {
+            kind: "callValue",
+            callee: source.closure,
+            args: [],
+            type: source.out,
+            loc,
+        };
+        return {
+            kind: "libCall",
+            fn: "readable.fromAsyncGen",
+            args: [gen, ...helpers, numLit(opts.flags, loc), hwm],
+            type,
+            loc,
+        };
+    }
     const srcT = srcNode ? lowerer.mapTypeOf(lowerer.typeOf(srcNode)) : null;
     const typedElem = (t) => t?.kind === "string" ? "string" : t?.kind === "bytes" && t.elem === "u8" ? "bytes" : null;
     const single = typedElem(srcT);
     const elem = srcT?.kind === "array" ? typedElem(srcT.elem) : null;
-    const opts = optsNode ? fromOptions(lowerer, optsNode) : { flags: 0, hwm: null };
+    const opts0 = optsNode ? fromOptions(lowerer, optsNode) : { flags: 0, hwm: null };
+    const opts = opts0 ? { ...opts0, flags: opts0.flags | duplexFlag } : opts0;
     // A class whose [Symbol.iterator]() or [Symbol.asyncIterator]() is a
     // generator method: from.js calls the method when the stream is built,
     // then reads the generator like any other.
@@ -1330,7 +1936,13 @@ export function lowerStreamStaticCall(lowerer, call, access) {
         };
     }
     const anySrc = srcT?.kind === "dyn" ||
-        (srcT?.kind === "set" && typedElem(srcT.elem) !== null) ||
+        // a Set or Map (entry arrays) of other values: the checked-dynamic
+        // view iterates the collection itself
+        ((srcT?.kind === "set" || srcT?.kind === "map") &&
+            canConvertToDyn(srcT, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) ||
+        // an array of other values: the object-mode entries come from its
+        // checked-dynamic copy
+        (srcT?.kind === "array" && fromGenChunk(lowerer, srcT.elem) && typedElem(srcT.elem) === null) ||
         (srcNode !== undefined &&
             srcT === null &&
             (lowerer.typeOf(srcNode).flags & ts.TypeFlags.Any) !== 0);
@@ -1338,25 +1950,25 @@ export function lowerStreamStaticCall(lowerer, call, access) {
         // The checked-dynamic form: the runtime takes from.js's ladder
         // (ERR_INVALID_ARG_TYPE for a non-iterable, the options, null values).
         const src = srcNode ? lowerer.lowerExprExpecting(srcNode, DYN) : dynUndefinedExpr(loc);
+        if (duplex)
+            return { kind: "libCall", fn: "stream.duplexFromDyn", args: [src], type, loc };
         const o = lowerOperatorValue(lowerer, optsNode, "Readable.from options", loc, true);
         return { kind: "libCall", fn: "readable.fromDyn", args: [src, o], type, loc };
     }
     if (srcNode && (single || elem)) {
         lowerer.noLowering("Readable.from with these options", optsNode, "an object literal with 'objectMode' (true or false) and a number 'highWaterMark' is supported");
     }
-    lowerer.noLowering(`Readable.from over a '${srcT ? lowerer.fmt(srcT) : "?"}' source`, srcNode ?? call, "the supported sources are a string or Buffer, and arrays, Sets, generators and class iterables of strings or Buffers");
+    lowerer.noLowering(`${what} over a '${srcT ? lowerer.fmt(srcT) : "?"}' source`, srcNode ?? call, "the supported sources are a string or Buffer, and arrays, Sets, Maps, generators and class iterables of values that convert to checked-dynamic values");
 }
-/** Whether a generator's yields are stream chunks: strings, Buffers, a
- * union of them (null included: the runtime destroys the stream with
- * ERR_STREAM_NULL_VALUES), or checked-dynamic values (checked when
- * pushed). */
+/** Whether a generator's yields can be stream chunks: values that box
+ * into checked-dynamic values (null included: the runtime destroys the
+ * stream with ERR_STREAM_NULL_VALUES). An object-mode stream takes any of
+ * them; a byte-mode one checks them when they are pushed or written. */
 function fromGenChunk(lowerer, t) {
-    const chunk = (a) => a.kind === "string" || (a.kind === "bytes" && a.elem === "u8") || a.kind === "nullT";
-    if (t.kind === "dyn" || (chunk(t) && t.kind !== "nullT"))
-        return true;
-    if (t.kind !== "union")
+    if (t.kind === "nullT" || t.kind === "void" || t.kind === "func")
         return false;
-    return lowerer.unions.get(t.unionId)?.arms.every(chunk) ?? false;
+    return (t.kind === "dyn" ||
+        canConvertToDyn(t, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)));
 }
 /** The helpers Readable.from pulls a compiled generator through, as
  * closures in libcall order: a sync generator's next/return/throw answer
@@ -1399,7 +2011,7 @@ function fromGenHelpers(lowerer, gen, loc) {
         const key = `streamFromGen:${role}:${typeKey(gen)}`;
         let name = lowerer.valueHelpers.get(key);
         if (!name) {
-            name = `%stream.fromGen.${role}.${lowerer.valueHelpers.size}`;
+            name = keyedHelperName(lowerer, `%stream.fromGen.${role}`, key);
             lowerer.valueHelpers.set(key, name);
             lowerer.liftedFns.push({
                 name,
@@ -1480,7 +2092,7 @@ function classIteratorObject(lowerer, cit, iter, loc) {
     const key = `streamFromIter:${cit.iterT.className}`;
     let name = lowerer.valueHelpers.get(key);
     if (!name) {
-        name = `%stream.fromIter.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%stream.fromIter", key);
         lowerer.valueHelpers.set(key, name);
         const nextName = `${name}.next`;
         const nextT = funcOf([], DYN);
@@ -1624,7 +2236,7 @@ function classAsyncIteratorObject(lowerer, cit, recv, loc) {
     const key = `streamFromAsyncIter:${cit.className}`;
     let name = lowerer.valueHelpers.get(key);
     if (!name) {
-        name = `%stream.fromAsyncIter.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%stream.fromAsyncIter", key);
         lowerer.valueHelpers.set(key, name);
         const it = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true };
         const src = {
@@ -1743,10 +2355,10 @@ const PIPELINE_STAGE_EXPECTED = "of type function or an instance of Blob, Readab
  * a ladder Node never throws. */
 function lowerStreamArg(lowerer, node, what) {
     const lowered = lowerer.lowerExpr(node);
-    // A Hash or Hmac stage is its Transform; pipeline and compose stages
-    // keep the value alive until the stream settles.
-    const v = isHashValueType(lowered.type)
-        ? hashStreamOf(lowered, what === "pipeline" || what === "compose")
+    // 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)
+        ? valueStreamOf(lowered, what === "pipeline" || what === "compose")
         : lowered;
     // A checked-dynamic pipeline stage (an untyped source or destination):
     // a boxed native stream unwraps at run time; other values (iterables,
@@ -1827,6 +2439,24 @@ class StreamArgTypeThrow extends Error {
         this.expr = expr;
     }
 }
+/** Whether a checked-dynamic pipeline callback can take undefined as its
+ * error: a callback that is already checked-dynamic, one without
+ * parameters, and one whose first parameter (or rest element) type holds
+ * undefined. */
+function callbackErrorAdmitsUndefined(lowerer, cb) {
+    if (cb.kind !== "dynFrom" || cb.value.type.kind !== "func")
+        return true;
+    const fnT = cb.value.type;
+    const first = fnT.params[0];
+    if (first === undefined)
+        return true;
+    const p0 = fnT.rest === true && fnT.params.length === 1 && first.kind === "array" ? first.elem : first;
+    if (p0.kind === "dyn" || p0.kind === "jsval" || p0.kind === "undefinedT")
+        return true;
+    if (p0.kind !== "union")
+        return false;
+    return lowerer.unions.get(p0.unionId)?.arms.some((a) => a.kind === "undefinedT") ?? false;
+}
 /** The finished/pipeline completion callback: an inline function lowers
  * through the option-callback machinery (leading `this`, an `Error |
  * null` prefix — Node binds the stream and passes the error); any other
@@ -2025,19 +2655,29 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
                 ? pipelineOptions(lowerer, lastArg)
                 : null;
             const stageArgs = opts ? args.slice(0, -1) : args;
-            if (stageArgs.some(isPipelineFunctionStage)) {
-                if (opts) {
-                    lowerer.noLowering("pipeline with function stages and options", lastArg, "pipeline(source, async function* (source) { ... }, destination) without options is supported");
-                }
+            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).
-                return staged.wrap({
-                    kind: "libCall",
-                    fn: "sp.pipelineStages",
-                    args: staged.args,
-                    type: staged.destPromise ?? { kind: "promise", inner: VOID },
-                    loc,
-                });
+                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 {
@@ -2091,7 +2731,10 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
             // (finished/pipeline throw synchronously; consumers do not). A
             // sync throw here would be observably wrong timing, so the
             // provable case takes the named fence instead.
-            const argV = lowerer.lowerExpr(args[0]);
+            // A Hash, Hmac, Cipheriv or Decipheriv is read through its Transform.
+            const argV = isValueStream(lowerer, args[0])
+                ? valueStreamOf(lowerer.lowerExpr(args[0]))
+                : lowerer.lowerExpr(args[0]);
             const argInfo = argV.type.kind === "object" ? lowerer.classes.get(argV.type.className) : undefined;
             if (argV.type.kind !== "dyn" && !streamSidesOf(lowerer, argInfo)) {
                 lowerer.noLowering(`stream/consumers.${bi.member} over a value that is not a stream`, call, "Node rejects the promise with 'stream is not async iterable' — pass a readable stream");
@@ -2190,20 +2833,30 @@ 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 (args.slice(0, -1).some(isPipelineFunctionStage)) {
+        if (hasPipelineFunctionStage(lowerer, args.slice(0, -1))) {
             const staged = lowerPipelineStages(lowerer, args.slice(0, -1), loc);
-            if (staged.dest !== 0) {
-                // callback(err, value): the destination's value reaches the
-                // callback through the checked-dynamic path. Node answers an
-                // object-mode PassThrough here; reading it has no lowering.
-                if (!ts.isExpressionStatement(call.parent)) {
-                    lowerer.noLowering("using the PassThrough that pipeline() answers for a function destination", call, "read the destination's value in the callback");
-                }
+            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: [...staged.args, cb],
+                    args: [...stagedArgs, cb],
                     type: staged.last,
                     loc,
                 });
@@ -2236,136 +2889,578 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
             loc,
         };
     }
-    if (bi.member === "compose")
-        return lowerStreamCompose(lowerer, call, 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);
+    }
     return null;
 }
-/** A pipeline() argument written as a function: an async generator
- * function stage. */
-function isPipelineFunctionStage(node) {
-    return ts.isFunctionExpression(node) || ts.isArrowFunction(node);
-}
-/** pipeline(...) with one run of function stages (pipeline.js). The run
- * may start the pipeline (a source function, called with `{ signal }`)
- * and may end it (a destination function: an async generator pumped into
- * a PassThrough, or an async function whose promise's value reaches the
- * callback or the promise). Each stage's `source` parameter is typed as
- * what the 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) {
-    const first = stageArgs.findIndex(isPipelineFunctionStage);
-    let end = first;
-    while (end < stageArgs.length && isPipelineFunctionStage(stageArgs[end]))
-        end++;
-    if (stageArgs.slice(end).some(isPipelineFunctionStage)) {
-        lowerer.noLowering("pipeline with function stages separated by streams", stageArgs[end], "one run of function stages is supported");
-    }
-    const source = first === 0;
-    const destFn = end === stageArgs.length;
-    const before = [];
-    const after = [];
+/** The function a pipeline() argument writes or names, or null when the
+ * argument is not a function stage. */
+function pipelineStageFunction(lowerer, node) {
+    if (ts.isFunctionExpression(node) || ts.isArrowFunction(node))
+        return node;
+    if (!ts.isIdentifier(node))
+        return null;
+    // The stage lowers the declaration's body again with its source typed
+    // by the pipeline, so resolving it here must not report what collecting
+    // the declaration's own signature deferred (resolveValueSymbol would).
+    const resolve = (ident) => {
+        const found = lowerer.checker.getSymbolAtLocation(ident);
+        return found && found.flags & ts.SymbolFlags.Alias
+            ? lowerer.checker.getAliasedSymbol(found)
+            : found;
+    };
+    const symbol = resolve(node);
+    const declarations = symbol?.declarations ?? [];
+    const bodies = declarations.filter((d) => !ts.isFunctionDeclaration(d) || d.body !== undefined);
+    if (!symbol || bodies.length !== 1)
+        return null;
+    const decl = bodies[0];
+    if (lowerer.isStdlibFile(ts.getSourceFileOfNode(decl)))
+        return null;
+    if (ts.isFunctionDeclaration(decl)) {
+        return bindingNeverReassigned(lowerer, symbol, decl, resolve) ? decl : null;
+    }
+    if (ts.isVariableDeclaration(decl) &&
+        decl.initializer &&
+        ts.isVariableDeclarationList(decl.parent) &&
+        (decl.parent.flags & ts.NodeFlags.Const) !== 0) {
+        let init = decl.initializer;
+        while (ts.isParenthesizedExpression(init))
+            init = init.expression;
+        if (ts.isFunctionExpression(init) || ts.isArrowFunction(init))
+            return init;
+    }
+    return null;
+}
+function hasPipelineFunctionStage(lowerer, args) {
+    return (args.some((a) => pipelineStageFunction(lowerer, a) !== null) ||
+        (args.length > 0 && iterableSourceType(lowerer, args[0]) !== null));
+}
+/** The element type of a pipeline source that is an iterable value (an
+ * array, a string or a synchronous generator object), or null. */
+function iterableSourceType(lowerer, node) {
+    if (pipelineStageFunction(lowerer, node) !== null)
+        return null;
+    const webElem = staticReadableStreamElementType(lowerer, node);
+    if (webElem !== null)
+        return webElem;
+    let t;
     try {
-        for (const a of stageArgs.slice(0, first))
-            before.push(lowerStreamArg(lowerer, a, "pipeline"));
+        t = lowerer.mapTypeOf(lowerer.typeOf(node));
     }
-    catch (e) {
-        if (e instanceof StreamArgTypeThrow)
-            lowerer.noLowering("pipeline over this value", stageArgs[0]);
-        throw e;
+    catch {
+        return null;
     }
-    let srcT = source ? null : before[before.length - 1].type;
-    const stages = [];
-    let mask = 0;
-    let dest = 0;
-    let destPromise = null;
-    for (let i = first; i < end; i++) {
-        const fn = stageArgs[i];
-        const isLast = destFn && i === end - 1;
-        const isAsync = (fn.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
-        const isGen = ts.isFunctionExpression(fn) && fn.asteriskToken !== undefined;
-        if (isLast && isGen) {
-            // pipeline() pumps it into an object-mode PassThrough, whose
-            // buffering decides when the pipeline finishes
-            lowerer.noLowering("a pipeline destination that is an async generator function", fn, "end the pipeline with a stream or an async function (source) { for await (const chunk of source) ... }");
-        }
-        if (!isAsync || (!isGen && !isLast)) {
-            lowerer.noLowering(isLast
-                ? "a pipeline destination that is not an async function"
-                : srcT === null
-                    ? "a pipeline source function that is not an async generator function"
-                    : "pipeline stages that are not async generator functions", fn, "write the stage as async function* (source) { for await (const chunk of source) ... }");
-        }
-        const optionsAt = srcT === null ? 0 : 1;
-        if (fn.parameters.nodes.length > optionsAt + 1) {
-            lowerer.noLowering("pipeline stages with parameters after the options argument", fn.parameters.nodes[optionsAt + 1], "a stage takes the source and { signal }");
-        }
-        const lowered = lowerStageFunction(lowerer, fn, srcT);
-        const params = lowered.closure.type.kind === "func" ? lowered.closure.type.params : [];
-        if (params.length > optionsAt) {
-            if (params[optionsAt].kind !== "dyn") {
-                lowerer.noLowering("a pipeline stage's options argument with this type", fn.parameters.nodes[optionsAt], "type it as { signal: AbortSignal }");
-            }
-            mask |= 1 << (i - first);
+    if (t?.kind === "array")
+        return t.elem;
+    if (t?.kind === "string")
+        return STRING;
+    if (t?.kind === "generator" && t.async !== true && stepDrivable(t))
+        return t.yieldT;
+    return null;
+}
+/** A pipeline source that is an iterable value or a synchronous generator
+ * function without parameters, as an async generator closure that steps
+ * the value's iterator (or the generator the function returns) and yields
+ * each element. Node's pipeline iterates such a source with `for await`,
+ * through an async-from-sync iterator, and an async generator that
+ * yields the same elements resumes its consumer on the same ticks. Null
+ * when the source has no such lowering. */
+/** A web ReadableStream source, as an async generator closure over its
+ * reader: each pass awaits reader.read() and yields the chunk, as the
+ * stream's async iterator does; leaving early cancels the stream (its
+ * iterator's return()), and the reader's lock is released either way. */
+function lowerWebStreamSource(lowerer, node, elemT, loc) {
+    const resultT = genResultRecord(elemT, VOID, lowerer.shapes, lowerer.unions);
+    if (!resultT)
+        return null;
+    const valueField = lowerer.shapes.get(resultT.shapeId)?.fields.find((f) => f.name === "value");
+    if (!valueField)
+        return null;
+    const out = {
+        kind: "generator",
+        async: true,
+        yieldT: elemT,
+        retT: VOID,
+        nextT: UNDEFINED_T,
+    };
+    const genResultT = genResultRecord(elemT, VOID, lowerer.shapes, lowerer.unions);
+    if (!genResultT)
+        return null;
+    const value = lowerer.lowerExprExpecting(node, DYN);
+    const key = `webStreamSource:${typeKey(elemT)}`;
+    let maker = lowerer.valueHelpers.get(key);
+    if (!maker) {
+        maker = `%stream.webStreamSource.${lowerer.valueHelpers.size}`;
+        const genName = `${maker}.gen`;
+        const frame = new LiftedFrame(loc);
+        const srcId = frame.local("src", DYN, false);
+        const readerId = frame.local("reader", DYN, false);
+        const activeId = frame.local("active", BOOL, true);
+        const promiseT = { kind: "promise", inner: resultT };
+        const pId = frame.local("p", promiseT, false);
+        const rId = frame.local("r", resultT, false);
+        const reader = () => varRef(readerId, DYN, loc);
+        const r = () => varRef(rId, resultT, loc);
+        const setActive = (on) => ({
+            kind: "assign",
+            localId: activeId,
+            value: { kind: "boolLit", value: on, type: BOOL, loc },
+            loc,
+        });
+        const extracted = extractIteratorValue(lowerer, elemT, valueField.type, {
+            kind: "recordGet",
+            obj: r(),
+            shapeId: resultT.shapeId,
+            field: "value",
+            type: valueField.type,
+            loc,
+        }, loc);
+        if (!extracted)
+            return null;
+        const invoke = (method, args, calleeName) => ({
+            kind: "dynInvoke",
+            recv: reader(),
+            method,
+            calleeName,
+            args,
+            type: DYN,
+            loc,
+        });
+        const body = [
+            {
+                kind: "varDecl",
+                localId: readerId,
+                init: {
+                    kind: "dynInvoke",
+                    recv: varRef(srcId, DYN, loc),
+                    method: "getReader",
+                    calleeName: "ReadableStream async iterator",
+                    args: [],
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "varDecl",
+                localId: activeId,
+                init: { kind: "boolLit", value: false, type: BOOL, loc },
+                loc,
+            },
+            {
+                kind: "tryCatch",
+                tryBody: [
+                    {
+                        kind: "while",
+                        cond: { kind: "boolLit", value: true, type: BOOL, loc },
+                        body: [
+                            setActive(false),
+                            {
+                                kind: "varDecl",
+                                localId: pId,
+                                init: {
+                                    kind: "libCall",
+                                    fn: "fetch.readerRead",
+                                    args: [reader()],
+                                    type: promiseT,
+                                    loc,
+                                },
+                                loc,
+                            },
+                            {
+                                kind: "varDecl",
+                                localId: rId,
+                                init: { kind: "awaitExpr", value: varRef(pId, promiseT, loc), type: resultT, loc },
+                                loc,
+                            },
+                            {
+                                kind: "if",
+                                cond: {
+                                    kind: "recordGet",
+                                    obj: r(),
+                                    shapeId: resultT.shapeId,
+                                    field: "done",
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: [{ kind: "break", loc }],
+                                else_: null,
+                                loc,
+                            },
+                            setActive(true),
+                            {
+                                kind: "exprStmt",
+                                expr: { kind: "yieldExpr", value: extracted, type: VOID, loc },
+                                loc,
+                            },
+                        ],
+                        loc,
+                    },
+                ],
+                catchBody: null,
+                catchLocalId: null,
+                finallyBody: [
+                    {
+                        kind: "tryCatch",
+                        tryBody: [
+                            {
+                                kind: "if",
+                                cond: varRef(activeId, BOOL, loc),
+                                then: [
+                                    {
+                                        kind: "exprStmt",
+                                        expr: {
+                                            kind: "libCall",
+                                            fn: "async.awaitDyn",
+                                            args: [
+                                                invoke("cancel", [dynUndefinedExpr(loc)], "ReadableStream async iterator return"),
+                                            ],
+                                            type: DYN,
+                                            loc,
+                                        },
+                                        loc,
+                                    },
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                        ],
+                        catchBody: null,
+                        catchLocalId: null,
+                        finallyBody: [
+                            {
+                                kind: "exprStmt",
+                                expr: invoke("releaseLock", [], "ReadableStream async iterator releaseLock"),
+                                loc,
+                            },
+                        ],
+                        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: elemT, 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);
+        if (webElem !== null)
+            return lowerWebStreamSource(lowerer, node, webElem, loc);
+    }
+    let value;
+    if (fn !== null) {
+        if (fn.parameters.nodes.length > 0) {
+            lowerer.noLowering("a synchronous generator function pipeline source with parameters", fn.parameters.nodes[0], "declare the source without parameters, or make it an async generator function");
         }
+        value = lowerer.lowerLambda(fn);
+        if (value.type.kind !== "func" || value.type.ret.kind !== "generator")
+            return null;
+    }
+    else {
+        value = lowerer.lowerExpr(node);
+    }
+    const srcT = value.type;
+    const elemT = srcT.kind === "func" && srcT.ret.kind === "generator"
+        ? srcT.ret.yieldT
+        : srcT.kind === "array"
+            ? srcT.elem
+            : srcT.kind === "string"
+                ? STRING
+                : srcT.kind === "generator" && srcT.async !== true
+                    ? srcT.yieldT
+                    : null;
+    if (elemT === null)
+        return null;
+    const out = {
+        kind: "generator",
+        async: true,
+        yieldT: elemT,
+        retT: VOID,
+        nextT: UNDEFINED_T,
+    };
+    const resultType = genResultRecord(elemT, VOID, lowerer.shapes, lowerer.unions);
+    if (!resultType)
+        return null;
+    const key = `pipelineSource:${typeKey(srcT)}`;
+    let maker = lowerer.valueHelpers.get(key);
+    if (!maker) {
+        maker = `%stream.pipelineSource.${lowerer.valueHelpers.size}`;
+        const genName = `${maker}.gen`;
+        // The generator: g = the source's iterator; for (v of g) yield v.
+        const frame = new LiftedFrame(loc);
+        const srcId = frame.local("src", srcT, false);
+        const src = varRef(srcId, srcT, loc);
+        const syncT = {
+            kind: "generator",
+            yieldT: elemT,
+            retT: VOID,
+            nextT: UNDEFINED_T,
+        };
+        let iterator;
+        if (srcT.kind === "func") {
+            iterator = { kind: "callValue", callee: src, args: [], type: srcT.ret, loc };
+        }
+        else if (srcT.kind === "array") {
+            iterator = lowerArrayIteratorValue(lowerer, src, "values", syncT, loc);
+        }
+        else if (srcT.kind === "string") {
+            iterator = lowerStringIteratorValue(lowerer, src, syncT, loc);
+        }
+        else {
+            iterator = src;
+        }
+        if (iterator === null || iterator.type.kind !== "generator" || !stepDrivable(iterator.type))
+            return null;
+        const iterT = iterator.type;
+        const gId = frame.local("g", iterT, false);
+        const body = [
+            { kind: "varDecl", localId: gId, init: iterator, loc },
+            ...driveGenerator(lowerer, frame, gId, iterT, elemT, [], (v) => [{ kind: "exprStmt", expr: { kind: "yieldExpr", value: v, type: VOID, loc }, 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: srcT }],
+            locals: frame.locals,
+            body,
+            generator: { yieldT: elemT, nextT: UNDEFINED_T, resultType },
+            loc,
+        });
+        // The maker: (src) => the generator function closed over src.
+        const makerSrc = { id: "src.0", name: "src", type: srcT, mutable: false, boxed: true };
+        lowerer.liftedFns.push({
+            name: maker,
+            params: [{ localId: makerSrc.id, name: makerSrc.name, type: srcT }],
+            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,
+    };
+}
+/** pipeline(...) with function stages (pipeline.js). A function may
+ * start the pipeline (a source function, called with `{ signal }`), may
+ * end it (an async function whose promise's value reaches the callback or
+ * the promise, or an async generator function), and runs of async
+ * generator functions may sit between streams; the last generator of a
+ * run that a stream follows is pumped into that stream. A function
+ * destination feeds the object-mode PassThrough that pipeline() answers. Each stage's `source` parameter is typed as what the
+ * 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) {
+    if (stageArgs.length > 52) {
+        lowerer.noLowering("pipeline with function stages and more than 52 stages", stageArgs[52], "split the pipeline");
+    }
+    const streams = [];
+    const stages = [];
+    const helperArgs = [];
+    let positions = 0;
+    let mask = 0;
+    let dest = 0;
+    let destPromise = null;
+    // What the next function stage receives: null before the first stage,
+    // else the previous stream's type or the previous stage's generator.
+    let srcT = null;
+    // The streams and stages in argument order: the head lists all streams
+    // before all stages, so when a stage precedes a stream the arguments
+    // are bound to locals first, keeping JavaScript's evaluation order.
+    const argOrder = [];
+    for (let j = 0; j < stageArgs.length; j++) {
+        const arg = stageArgs[j];
+        // compose's head and tail functions arrive as Duplex.from streams
+        const fn = preLowered?.has(j) ? null : pipelineStageFunction(lowerer, arg);
+        const syncSourceFn = j === 0 &&
+            fn !== null &&
+            !ts.isArrowFunction(fn) &&
+            fn.asteriskToken !== undefined &&
+            !(fn.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+        if (j === 0 &&
+            !preLowered?.has(j) &&
+            (syncSourceFn || (fn === null && iterableSourceType(lowerer, arg) !== null))) {
+            const source = lowerIterableSource(lowerer, arg, syncSourceFn ? fn : null, 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;
+        }
+        if (fn === null) {
+            if (srcT?.kind === "generator") {
+                // the generator before this stream, pumped into it
+                if (!fromGenChunk(lowerer, srcT.yieldT)) {
+                    lowerer.noLowering(`a pipeline stage yielding '${lowerer.fmt(srcT.yieldT)}'`, stageArgs[j - 1], "stage values written to a stream are strings or Buffers");
+                }
+                const helpers = fromGenHelpers(lowerer, srcT, loc);
+                if (!helpers)
+                    lowerer.noLowering("a pipeline stage with this generator type", stageArgs[j - 1]);
+                helperArgs.push(helpers[0], helpers[1], helpers[2]);
+            }
+            let stream;
+            try {
+                stream = preLowered?.get(j) ?? lowerStreamArg(lowerer, arg, "pipeline");
+            }
+            catch (e) {
+                if (e instanceof StreamArgTypeThrow)
+                    lowerer.noLowering("pipeline over this value", arg);
+                throw e;
+            }
+            argOrder.push({ list: streams, index: streams.length });
+            streams.push(stream);
+            srcT = stream.type;
+            continue;
+        }
+        const isLast = j === stageArgs.length - 1;
+        const isAsync = (fn.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+        const isGen = !ts.isArrowFunction(fn) && fn.asteriskToken !== undefined;
+        if (!isAsync || (!isGen && !isLast)) {
+            lowerer.noLowering(isLast
+                ? "a pipeline destination that is not an async function"
+                : srcT === null
+                    ? "a pipeline source function that is not an async generator function"
+                    : "pipeline stages that are not async generator functions", arg, "write the stage as async function* (source) { for await (const chunk of source) ... }");
+        }
+        const optionsAt = srcT === null ? 0 : 1;
+        if (fn.parameters.nodes.length > optionsAt + 1) {
+            lowerer.noLowering("pipeline stages with parameters after the options argument", fn.parameters.nodes[optionsAt + 1], "a stage takes the source and { signal }");
+        }
+        const lowered = lowerStageFunction(lowerer, fn, srcT);
+        const params = lowered.closure.type.kind === "func" ? lowered.closure.type.params : [];
+        if (params.length > optionsAt) {
+            if (params[optionsAt].kind !== "dyn") {
+                lowerer.noLowering("a pipeline stage's options argument with this type", fn.parameters.nodes[optionsAt], "type it as { signal: AbortSignal }");
+            }
+            mask |= 1 << stages.length;
+        }
+        positions += 2 ** j;
+        argOrder.push({ list: stages, index: stages.length });
         stages.push(lowered.closure);
         if (lowered.out.kind === "promise") {
             dest = 2;
             destPromise = lowered.out;
             srcT = null;
         }
+        else if (isLast) {
+            // an async generator destination: pumped into the object-mode
+            // PassThrough that pipeline() answers
+            const helpers = fromGenHelpers(lowerer, lowered.out, loc);
+            if (!helpers)
+                lowerer.noLowering("a pipeline destination with this generator type", arg);
+            helperArgs.push(helpers[0], helpers[1], helpers[2]);
+            dest = 1;
+            srcT = null;
+        }
         else {
             srcT = lowered.out;
         }
     }
-    try {
-        for (const a of stageArgs.slice(end))
-            after.push(lowerStreamArg(lowerer, a, "pipeline"));
-    }
-    catch (e) {
-        if (e instanceof StreamArgTypeThrow)
-            lowerer.noLowering("pipeline over this value", stageArgs[end]);
-        throw e;
-    }
-    const helperArgs = [];
-    if (dest !== 2) {
-        // the generator pumped into the next stream or the PassThrough
-        const lastGen = srcT;
-        if (!fromGenChunk(lowerer, lastGen.yieldT)) {
-            lowerer.noLowering(`a pipeline stage yielding '${lowerer.fmt(lastGen.yieldT)}'`, stageArgs[end - 1], "stage values written to a stream are strings or Buffers");
-        }
-        const helpers = fromGenHelpers(lowerer, lastGen, loc);
-        if (!helpers)
-            lowerer.noLowering("a pipeline stage with this generator type", stageArgs[end - 1]);
-        helperArgs.push(helpers[0], helpers[1], helpers[2]);
-    }
-    else {
+    if (dest === 2) {
         const valueT = destPromise.inner;
         if (valueT.kind !== "void" &&
             !canConvertToDyn(valueT, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-            lowerer.noLowering(`a pipeline destination resolving to '${lowerer.fmt(valueT)}'`, stageArgs[end - 1]);
+            lowerer.noLowering(`a pipeline destination resolving to '${lowerer.fmt(valueT)}'`, stageArgs[stageArgs.length - 1]);
         }
         helperArgs.push(pipelineBoxHelper(lowerer, destPromise, loc));
     }
-    const streams = [...before, ...after];
-    // SCR_PIPE_* flags: bit 0 a source function, bits 1-2 the destination,
-    // bit 3 the helpers, bit 4 the box, bit 5 the signal and abort.
-    const flags = (source ? 1 : 0) | (dest << 1) | (dest !== 2 ? 8 : 16) | (mask !== 0 ? 32 : 0);
+    const argDecls = [];
+    const firstStage = argOrder.findIndex((a) => a.list === stages);
+    if (firstStage >= 0 && argOrder.slice(firstStage).some((a) => a.list === streams)) {
+        for (const a of argOrder) {
+            const init = a.list[a.index];
+            const local = lowerer.declareHiddenLocal("%pipelineArg", init.type);
+            argDecls.push({ kind: "varDecl", localId: local.id, init, loc: init.loc });
+            a.list[a.index] = varRef(local.id, init.type, init.loc);
+        }
+    }
+    const bindArgs = (call) => argDecls.length === 0
+        ? call
+        : { kind: "seqExpr", stmts: argDecls, result: call, type: call.type, loc };
+    // SCR_PIPE_* flags: bits 1-2 the destination, bit 5 the signal and
+    // abort (bit 6, the promise form's options signal, is set by its caller).
+    const flags = (dest << 1) | (mask !== 0 ? 32 : 0);
     const head = [
         numLit(streams.length, loc),
-        numLit(before.length, loc),
         numLit(stages.length, loc),
+        numLit(positions, loc),
         numLit(flags, loc),
         numLit(mask, loc),
         ...streams,
         ...stages,
         ...helperArgs,
     ];
-    const last = destFn
-        ? { kind: "object", className: "%PassThrough" }
-        : streams[streams.length - 1].type;
+    const last = dest !== 0 ? { kind: "object", className: "%PassThrough" } : streams[streams.length - 1].type;
     if (mask === 0)
-        return { args: head, last, dest, destPromise, wrap: (call) => call };
+        return { args: head, last, dest, destPromise, wrap: bindArgs };
     // const ac = new AbortController(): its signal goes to the stages, and
     // finishImpl's ac.abort() runs through the abort closure.
     const ac = lowerer.declareHiddenLocal("%pipelineAbort", DYN);
@@ -2382,7 +3477,7 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
         last,
         dest,
         destPromise,
-        wrap: (call) => ({
+        wrap: (call) => bindArgs({
             kind: "seqExpr",
             stmts: [
                 {
@@ -2405,7 +3500,7 @@ function pipelineBoxHelper(lowerer, promiseT, loc) {
     const key = `pipelineBox:${typeKey(promiseT)}`;
     let name = lowerer.valueHelpers.get(key);
     if (!name) {
-        name = `%stream.pipelineBox.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%stream.pipelineBox", key);
         lowerer.valueHelpers.set(key, name);
         lowerer.liftedFns.push({
             name,
@@ -2426,21 +3521,22 @@ function pipelineBoxHelper(lowerer, promiseT, loc) {
 }
 /** `() => ac.abort()` over the pipeline's AbortController: an interned
  * lifted function takes the controller and answers the closure. */
-function pipelineAbortHelper(lowerer, ac, loc) {
-    const key = "pipelineAbort";
+function pipelineAbortHelper(lowerer, ac, loc, withReason = false) {
+    const key = withReason ? "pipelineAbortReason" : "pipelineAbort";
     let name = lowerer.valueHelpers.get(key);
-    const abortT = funcOf([], VOID);
+    const abortT = funcOf(withReason ? [DYN] : [], VOID);
     if (!name) {
-        name = `%stream.pipelineAbort.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%stream.pipelineAbort", key);
         lowerer.valueHelpers.set(key, name);
         const acLocal = { id: "ac.0", name: "ac", type: DYN, mutable: false, boxed: true };
         const acRef = varRef(acLocal.id, DYN, loc);
+        const reasonLocal = { id: "reason.0", name: "reason", type: DYN, mutable: false };
         lowerer.liftedFns.push({
             name: `${name}.abort`,
-            params: [],
+            params: withReason ? [{ localId: reasonLocal.id, name: reasonLocal.name, type: DYN }] : [],
             returnType: VOID,
             captures: [{ localId: acLocal.id, name: acLocal.name, type: DYN }],
-            locals: [acLocal],
+            locals: withReason ? [acLocal, reasonLocal] : [acLocal],
             body: [
                 {
                     kind: "exprStmt",
@@ -2449,7 +3545,7 @@ function pipelineAbortHelper(lowerer, ac, loc) {
                         recv: acRef,
                         method: "abort",
                         calleeName: "ac.abort",
-                        args: [],
+                        args: withReason ? [varRef(reasonLocal.id, DYN, loc)] : [],
                         type: DYN,
                         loc,
                     },
@@ -2494,6 +3590,8 @@ function lowerStageFunction(lowerer, fn, srcT) {
     if (param && !symbol) {
         lowerer.noLowering("pipeline stage parameters that are patterns", param, "name the source parameter");
     }
+    // The loop variables of the `for await` loops over the source.
+    const chunkSymbols = [];
     if (symbol && fn.body) {
         const visit = (node) => {
             if (ts.isIdentifier(node) &&
@@ -2506,6 +3604,14 @@ function lowerStageFunction(lowerer, fn, srcT) {
                     parent.expression === node)) {
                     lowerer.noLowering("a pipeline stage's source used outside a for await loop head", node, "iterate the source with for await (const chunk of source)");
                 }
+                const binding = ts.isVariableDeclarationList(parent.initializer)
+                    ? parent.initializer.declarations.nodes[0]?.name
+                    : undefined;
+                const chunk = binding && ts.isIdentifier(binding)
+                    ? lowerer.checker.getSymbolAtLocation(binding)
+                    : undefined;
+                if (chunk)
+                    chunkSymbols.push(chunk);
             }
             ts.forEachChild(node, visit);
         };
@@ -2513,8 +3619,22 @@ function lowerStageFunction(lowerer, fn, srcT) {
     }
     if (symbol)
         lowerer.stageSourceTypes.set(symbol, srcT);
+    // In JavaScript the checker types the chunks of a source that is the
+    // previous stage's generator `any`; they read as the strings or Buffers
+    // the generator yields, so their members take the string and Buffer
+    // lowerings.
+    const previousImplicit = lowerer.implicitParamTypes;
+    const chunkType = srcT?.kind === "generator" && isJsSourceFile(ts.getSourceFileOfNode(fn))
+        ? stageChunkCheckerType(lowerer, srcT.yieldT, fn)
+        : null;
+    if (chunkType && chunkSymbols.length > 0) {
+        const implicit = new Map(previousImplicit ?? []);
+        for (const chunk of chunkSymbols)
+            implicit.set(chunk, chunkType);
+        lowerer.implicitParamTypes = implicit;
+    }
     try {
-        const closure = lowerer.lowerExpr(fn);
+        const closure = lowerer.lowerLambda(fn);
         const out = closure.type.kind === "func" ? closure.type.ret : null;
         if (!(out?.kind === "generator" && out.async) && out?.kind !== "promise") {
             lowerer.noLowering("a pipeline stage that does not return an async generator", fn);
@@ -2524,25 +3644,391 @@ function lowerStageFunction(lowerer, fn, srcT) {
     finally {
         if (symbol)
             lowerer.stageSourceTypes.delete(symbol);
+        lowerer.implicitParamTypes = previousImplicit;
+    }
+}
+/** The async generator a Duplex.from body iterates (duplexify.js's
+ * fromAsyncGen source), as a closure the runtime calls with next() and
+ * ack(): each pass awaits next() (the deferred a write or the final
+ * settles), calls ack() (process.nextTick(cb) and a fresh deferred),
+ * returns at the done marker, and yields the chunk. */
+function duplexSourceHelper(lowerer, genT, loc) {
+    const nextT = funcOf([], { kind: "promise", inner: DYN });
+    const ackT = funcOf([], VOID);
+    const type = funcOf([nextT, ackT], genT);
+    const key = "duplexSource";
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        const resultType = genResultRecord(DYN, VOID, lowerer.shapes, lowerer.unions);
+        if (!resultType)
+            return null;
+        name = `%stream.duplexSource.${lowerer.valueHelpers.size}`;
+        const frame = new LiftedFrame(loc);
+        const nextId = frame.param("next", nextT);
+        const ackId = frame.param("ack", ackT);
+        const valueId = frame.local("value", DYN, false);
+        const value = varRef(valueId, DYN, loc);
+        const body = [
+            {
+                kind: "while",
+                cond: { kind: "boolLit", value: true, type: BOOL, loc },
+                body: [
+                    {
+                        kind: "varDecl",
+                        localId: valueId,
+                        init: {
+                            kind: "awaitExpr",
+                            value: {
+                                kind: "callValue",
+                                callee: varRef(nextId, nextT, loc),
+                                args: [],
+                                type: { kind: "promise", inner: DYN },
+                                loc,
+                            },
+                            type: DYN,
+                            loc,
+                        },
+                        loc,
+                    },
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "callValue",
+                            callee: varRef(ackId, ackT, loc),
+                            args: [],
+                            type: VOID,
+                            loc,
+                        },
+                        loc,
+                    },
+                    {
+                        kind: "if",
+                        cond: { kind: "libCall", fn: "stream.chunkDone", args: [value], type: BOOL, loc },
+                        then: [{ kind: "return", value: null, loc }],
+                        else_: null,
+                        loc,
+                    },
+                    { kind: "exprStmt", expr: { kind: "yieldExpr", value, type: VOID, loc }, loc },
+                ],
+                loc,
+            },
+            { kind: "return", value: null, loc },
+        ];
+        lowerer.valueHelpers.set(key, name);
+        lowerer.liftedFns.push({
+            name,
+            params: frame.params,
+            returnType: VOID,
+            async: true,
+            locals: frame.locals,
+            body,
+            generator: { yieldT: DYN, nextT: UNDEFINED_T, resultType },
+            loc,
+        });
     }
+    return { kind: "closure", fnName: name, captures: [], type, loc };
+}
+/** Duplex.from(body) (duplexify.js) for the bodies with a lowering: an
+ * async generator function, whose source generator the Duplex's writes
+ * feed (stream.duplexFromGen); a duplex stream, which answers itself; and
+ * the bodies Readable.from reads (iterables, strings, generators), as a
+ * Duplexify that is not writable. */
+function duplexFromBody(lowerer, node, loc) {
+    const duplex = { kind: "object", className: "%Duplex" };
+    const fn = pipelineStageFunction(lowerer, node);
+    if (fn !== null) {
+        const isAsync = (fn.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+        const isGen = !ts.isArrowFunction(fn) && fn.asteriskToken !== undefined;
+        if (!isAsync) {
+            lowerer.noLowering("Duplex.from over a function that is not async", node, "write the body as async function* (source) { ... } or async function (source) { ... }");
+        }
+        if (fn.parameters.nodes.length > 2) {
+            lowerer.noLowering("a Duplex.from body with parameters after the options argument", fn.parameters.nodes[2], "the body takes the source and { signal }");
+        }
+        const sourceT = {
+            kind: "generator",
+            async: true,
+            yieldT: DYN,
+            retT: VOID,
+            nextT: UNDEFINED_T,
+        };
+        const lowered = lowerStageFunction(lowerer, fn, sourceT);
+        const params = lowered.closure.type.kind === "func" ? lowered.closure.type.params : [];
+        // fromAsyncGen calls the body with { signal } of an AbortController
+        // that destroy aborts with its error.
+        let signalArgs = [];
+        let signalDecls = [];
+        if (params.length > 1) {
+            if (params[1].kind !== "dyn") {
+                lowerer.noLowering("a Duplex.from body's options argument with this type", fn.parameters.nodes[1], "type it as { signal: AbortSignal }");
+            }
+            const acLocal = lowerer.declareHiddenLocal("%duplexAbort", DYN);
+            const ac = varRef(acLocal.id, DYN, loc);
+            signalDecls = [
+                {
+                    kind: "varDecl",
+                    localId: acLocal.id,
+                    init: { kind: "libCall", fn: "fetch.abortControllerNew", args: [], type: DYN, loc },
+                    loc,
+                },
+            ];
+            signalArgs = [
+                pipelineAbortHelper(lowerer, ac, loc, true),
+                { kind: "dynKeyGet", value: ac, key: strLit("signal", loc), type: DYN, loc },
+            ];
+        }
+        const withSignal = (fnName, args) => {
+            const call = {
+                kind: "libCall",
+                fn: signalArgs.length > 0 ? `${fnName}Signal` : fnName,
+                args: [...args, ...signalArgs],
+                type: duplex,
+                loc,
+            };
+            return signalDecls.length > 0
+                ? { kind: "seqExpr", stmts: signalDecls, result: call, type: duplex, loc }
+                : call;
+        };
+        if (!isGen) {
+            // an async function: a writable Duplexify whose final waits for
+            // the function's promise
+            const asyncSource = duplexSourceHelper(lowerer, sourceT, loc);
+            const out = lowered.out;
+            if (out.kind !== "promise" || !asyncSource)
+                return lowerer.noLowering("Duplex.from over a function with this return type", node);
+            if (out.inner.kind !== "void" &&
+                !canConvertToDyn(out.inner, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                lowerer.noLowering(`Duplex.from over a function resolving to '${lowerer.fmt(out.inner)}'`, node);
+            }
+            return withSignal("stream.duplexFromAsyncFn", [
+                lowered.closure,
+                asyncSource,
+                pipelineBoxHelper(lowerer, out, loc),
+            ]);
+        }
+        const helpers = lowered.out.kind === "generator" ? fromGenHelpers(lowerer, lowered.out, loc) : null;
+        const source = duplexSourceHelper(lowerer, sourceT, loc);
+        if (!helpers || !source)
+            lowerer.noLowering("Duplex.from over a function with this generator type", node);
+        return withSignal("stream.duplexFromGen", [lowered.closure, source, ...helpers]);
+    }
+    // duplexify.js: a stream answers itself (a Duplex) or is wrapped; any
+    // other body reads as from(Duplexify, body, { objectMode: true,
+    // writable: false })
+    let bodyT;
+    try {
+        bodyT = lowerer.mapTypeOf(lowerer.typeOf(node));
+    }
+    catch {
+        bodyT = null;
+    }
+    const bodySides = bodyT?.kind === "object" ? streamSidesOf(lowerer, lowerer.classes.get(bodyT.className)) : null;
+    let literal = node;
+    while (ts.isParenthesizedExpression(literal))
+        literal = literal.expression;
+    if (bodySides === null && ts.isObjectLiteralExpression(literal))
+        return duplexFromPair(lowerer, literal, loc);
+    if (bodyT?.kind === "promise") {
+        // a Duplexify that reads the promise's value
+        const valueT = bodyT.inner;
+        if (valueT.kind !== "void" &&
+            !canConvertToDyn(valueT, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+            lowerer.noLowering(`Duplex.from over a promise of '${lowerer.fmt(valueT)}'`, node);
+        }
+        const promise = lowerer.lowerExpr(node);
+        if (promise.type.kind !== "promise") {
+            // a checked-dynamic promise (an untyped function's result)
+            return {
+                kind: "libCall",
+                fn: "stream.duplexFromDyn",
+                args: [lowerer.coerceToExpected(promise, DYN)],
+                type: { kind: "object", className: "%Duplex" },
+                loc,
+            };
+        }
+        return {
+            kind: "libCall",
+            fn: "stream.duplexFromPromise",
+            args: [
+                promise,
+                pipelineBoxHelper(lowerer, promise.type, loc),
+            ],
+            type: { kind: "object", className: "%Duplex" },
+            loc,
+        };
+    }
+    if (bodySides === null)
+        return lowerFromSource(lowerer, node, node, undefined, true);
+    let stream;
+    try {
+        stream = lowerStreamArg(lowerer, node, "compose");
+    }
+    catch (e) {
+        if (e instanceof StreamArgTypeThrow)
+            return e.expr;
+        throw e;
+    }
+    const sides = stream.type.kind === "object"
+        ? streamSidesOf(lowerer, lowerer.classes.get(stream.type.className))
+        : null;
+    // _duplexify({ readable }) / _duplexify({ writable })
+    if (sides === "r" || sides === "w") {
+        return {
+            kind: "libCall",
+            fn: sides === "r" ? "stream.duplexifyReadable" : "stream.duplexifyWritable",
+            args: [stream],
+            type: duplex,
+            loc,
+        };
+    }
+    if (sides !== "rw") {
+        lowerer.noLowering("Duplex.from over a value of this type", node, "an async generator function, an iterable, a stream, or a { readable, writable } pair is the lowered body");
+    }
+    return stream;
+}
+/** Duplex.from({ readable, writable }): each member that is a stream with
+ * that side is used as it is, any other member is Duplex.from of it, and
+ * the pair reads and writes through _duplexify (duplexify.js). The
+ * members evaluate in source order. */
+function duplexFromPair(lowerer, literal, loc) {
+    const duplex = { kind: "object", className: "%Duplex" };
+    const sides = {};
+    // The members in source order; when that is not (readable, writable),
+    // each value is bound to a local first, keeping the literal's
+    // evaluation order.
+    const members = [];
+    for (const p of literal.properties.nodes) {
+        const key = (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) && ts.isIdentifier(p.name)
+            ? p.name.text
+            : null;
+        if (key !== "readable" && key !== "writable") {
+            lowerer.noLowering("Duplex.from over an object with members other than readable and writable", p, "pass { readable, writable } with streams or Duplex.from bodies");
+        }
+        const value = ts.isShorthandPropertyAssignment(p)
+            ? p.name
+            : p.initializer;
+        let valueT;
+        try {
+            valueT = lowerer.mapTypeOf(lowerer.typeOf(value));
+        }
+        catch {
+            valueT = null;
+        }
+        const valueSides = valueT?.kind === "object"
+            ? streamSidesOf(lowerer, lowerer.classes.get(valueT.className))
+            : null;
+        const wanted = key === "readable" ? "r" : "w";
+        const direct = valueSides === "rw" || valueSides === wanted;
+        members.push({
+            key: key,
+            value: direct
+                ? lowerStreamArg(lowerer, value, "compose")
+                : duplexFromBody(lowerer, value, loc),
+        });
+    }
+    const decls = [];
+    const inOrder = members.length <= 1 ||
+        (members.length === 2 && members[0].key === "readable" && members[1].key === "writable");
+    for (const m of members) {
+        if (inOrder) {
+            sides[m.key] = m.value;
+            continue;
+        }
+        const local = lowerer.declareHiddenLocal(`%duplex${m.key}`, m.value.type);
+        decls.push({ kind: "varDecl", localId: local.id, init: m.value, loc });
+        sides[m.key] = varRef(local.id, m.value.type, loc);
+    }
+    const { readable, writable } = sides;
+    if (readable && writable) {
+        const call = {
+            kind: "libCall",
+            fn: "stream.duplexifyPair",
+            args: [readable, writable],
+            type: duplex,
+            loc,
+        };
+        return decls.length > 0
+            ? { kind: "seqExpr", stmts: decls, result: call, type: duplex, loc }
+            : call;
+    }
+    if (decls.length > 0) {
+        // a repeated member: every value is evaluated, the last one is used
+        const one = readable ?? writable;
+        const call = {
+            kind: "libCall",
+            fn: readable ? "stream.duplexifyReadable" : "stream.duplexifyWritable",
+            args: [one],
+            type: duplex,
+            loc,
+        };
+        return { kind: "seqExpr", stmts: decls, result: call, type: duplex, loc };
+    }
+    if (readable)
+        return { kind: "libCall", fn: "stream.duplexifyReadable", args: [readable], type: duplex, loc };
+    if (writable)
+        return { kind: "libCall", fn: "stream.duplexifyWritable", args: [writable], type: duplex, loc };
+    return lowerer.noLowering("Duplex.from over an object with neither readable nor writable", literal, "pass { readable, writable } with streams or Duplex.from bodies");
+}
+/** The checker type of a stage's string or Buffer chunks, or null for
+ * other chunk types. */
+function stageChunkCheckerType(lowerer, chunk, at) {
+    if (chunk.kind === "string")
+        return lowerer.checker.getStringType();
+    if (chunk.kind !== "bytes")
+        return null;
+    const buffer = lowerer.checker.resolveName("Buffer", ts.SymbolFlags.Type, at, false);
+    return buffer ? lowerer.checker.getDeclaredTypeOfSymbol(buffer) : null;
 }
 /** `stream.compose(...streams)` over stream instances: a Duplex writing
  * to the first stream and reading from the last (scr_stream_compose). The
  * classes fix which positions can be readable and writable; a stream in
  * the wrong position, a single Readable or Writable (Duplex.from wraps
  * those), and functions, iterables or web streams have no lowering. */
-function lowerStreamCompose(lowerer, call, loc) {
-    const args = call.arguments.nodes;
+function lowerStreamCompose(lowerer, args, loc) {
     const duplex = { kind: "object", className: "%Duplex" };
-    if (args.some((a) => ts.isSpreadElement(a))) {
-        lowerer.noLowering("compose with spread arguments", call, "pass the streams directly");
-    }
     if (args.length === 0) {
         return nodeThrowExpr(1, "ERR_MISSING_ARGS", 'The "streams" argument must be specified', duplex, loc);
     }
+    // A web ReadableStream first stage reads as an async iterable (the
+    // pipeline's source), and alone it is Duplex.from of it; a later stage
+    // would be Duplex.fromWeb of it.
+    for (let i = 1; i < args.length; i++) {
+        const a = args[i];
+        // (typeOf on a stage function's name would report what collecting its
+        // declared signature deferred)
+        if (pipelineStageFunction(lowerer, a) !== null)
+            continue;
+        if (staticReadableStreamElementType(lowerer, a) !== null) {
+            lowerer.noLowering("compose with a web ReadableStream after the first stage", a, "a web ReadableStream is supported as the first stage of compose or pipeline, and in Readable.from");
+        }
+    }
+    // Duplex.from(stage) for one stage (duplexify.js), and for a function at
+    // either end; functions between, an iterable first stage or a source
+    // function run as the pipeline's function stages (compose.js)
+    if (args.length === 1)
+        return duplexFromBody(lowerer, args[0], loc);
+    const last = args.length - 1;
+    const isFn = (i) => pipelineStageFunction(lowerer, args[i]) !== null;
+    const pre = new Map();
+    if (isFn(0))
+        pre.set(0, duplexFromBody(lowerer, args[0], loc));
+    if (isFn(last))
+        pre.set(last, duplexFromBody(lowerer, args[last], loc));
+    const staged = args.some((_, i) => !pre.has(i) && isFn(i)) ||
+        (!pre.has(0) && iterableSourceType(lowerer, args[0]) !== null);
+    if (staged) {
+        const lowered = lowerPipelineStages(lowerer, args, loc, pre);
+        return lowered.wrap({
+            kind: "libCall",
+            fn: "stream.composeStages",
+            args: lowered.args,
+            type: duplex,
+            loc,
+        });
+    }
     let streams;
     try {
-        streams = args.map((a) => lowerStreamArg(lowerer, a, "compose"));
+        streams = args.map((a, i) => pre.get(i) ?? lowerStreamArg(lowerer, a, "compose"));
     }
     catch (e) {
         if (e instanceof StreamArgTypeThrow)
@@ -2574,6 +4060,28 @@ function lowerStreamCompose(lowerer, call, loc) {
 /* ── the method surface ───────────────────────────────────────────────── */
 /* ── the Readable operators ──────────────────────────────────────────── */
 /** The Readable operators (scr_stream_ops.c — Node's operators.js). */
+/** A stream member's receiver, lowered: a value the checker types as a
+ * stream class whose lowering is checked-dynamic (a JavaScript binding
+ * that holds an untyped call's result) or a union (an element read)
+ * converts to that class, checked where the member runs. */
+function streamReceiverExpr(lowerer, node) {
+    const value = lowerer.lowerExpr(node);
+    if (value.type.kind !== "dyn" && value.type.kind !== "union")
+        return value;
+    let classT;
+    try {
+        classT = lowerer.mapTypeOf(lowerer.typeOf(node));
+    }
+    catch {
+        return value;
+    }
+    if (classT?.kind !== "object" ||
+        streamSidesOf(lowerer, lowerer.classes.get(classT.className)) === null)
+        return value;
+    return value.type.kind === "dyn"
+        ? { kind: "dynCheck", value, type: classT, loc: value.loc }
+        : lowerer.coerceToExpected(value, classT);
+}
 export const STREAM_OPERATORS = new Set([
     "map",
     "filter",
@@ -2587,50 +4095,125 @@ export const STREAM_OPERATORS = new Set([
     "find",
     "reduce",
 ]);
-/** An operator callback as a checked-dynamic function value. Callbacks
- * that declare the options argument ({ signal }) are refused: the
- * AbortSignal Node passes there has no representation. map and flatMap
- * callbacks must produce strings or Buffers (flatMap: arrays of them, or
- * strings) — or checked-dynamic values, which the runtime checks. */
+/** An operator callback as a checked-dynamic function value, and whether
+ * it declares the options argument ({ signal }), which the runtime then
+ * passes. Its results convert to checked-dynamic values (flatMap's are
+ * iterated with yield*). */
 function lowerOperatorCallback(lowerer, node, member, maxParams) {
     const loc = locOf(node);
-    const optionsParam = (at) => lowerer.noLowering(`${member} callbacks that declare the options argument`, at, "the { signal } argument has no lowering — take only the chunk");
-    if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
-        node.parameters.nodes.length > maxParams) {
-        optionsParam(node.parameters.nodes[maxParams]);
+    const optionsParam = (at) => lowerer.noLowering(`${member} callbacks with parameters after the options argument`, at, "the callback takes the chunk and { signal }");
+    let takesOptions = false;
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        if (node.parameters.nodes.length > maxParams + 1)
+            optionsParam(node.parameters.nodes[maxParams + 1]);
+        takesOptions = node.parameters.nodes.length > maxParams;
     }
     const v = lowerer.lowerExpr(node);
+    // A checked-dynamic function's parameters are not known here: it gets
+    // the { signal } argument, as Node passes it to every callback.
     if (v.type.kind === "dyn")
-        return v;
+        return { fn: v, takesOptions: true };
     if (v.type.kind !== "func" &&
         isJsSourceFile(ts.getSourceFileOfNode(node)) &&
         lowerer.dynConvertible(v.type)) {
         // JavaScript passes any value; Node's validateFunction throws.
-        return { kind: "dynFrom", value: v, type: DYN, loc };
+        return { fn: { kind: "dynFrom", value: v, type: DYN, loc }, takesOptions: false };
     }
     if (v.type.kind !== "func") {
         lowerer.noLowering(`${member} with a '${lowerer.fmt(v.type)}' callback`, node, "pass a function");
     }
-    if (v.type.params.length > maxParams)
+    if (v.type.params.length > maxParams + 1)
         optionsParam(node);
-    if (member === "map" || member === "flatMap") {
-        const ret = v.type.ret.kind === "promise" ? v.type.ret.inner : v.type.ret;
-        const chunk = (t) => t.kind === "string" || t.kind === "dyn" || (t.kind === "bytes" && t.elem === "u8");
-        const ok = member === "map"
-            ? chunk(ret)
-            : ret.kind === "dyn" || ret.kind === "string" || (ret.kind === "array" && chunk(ret.elem));
-        if (!ok) {
-            lowerer.noLowering(`${member} callbacks that return '${lowerer.fmt(ret)}'`, node, member === "map"
-                ? "map results are stream chunks: strings or Buffers (object-mode streams of other values are not lowered)"
-                : "flatMap results are arrays of strings or Buffers, or strings");
-        }
-    }
+    if (v.type.params.length > maxParams)
+        takesOptions = true;
     const getRecord = (id) => lowerer.shapes.get(id);
     const getUnion = (id) => lowerer.unions.get(id);
     if (!canBoxFuncIntoDyn(v.type, getRecord, getUnion)) {
         lowerer.noLowering(`${member} with this callback`, node, "the callback's parameter and result types must cross the checked-dynamic boundary");
     }
-    return { kind: "dynFrom", value: v, type: DYN, loc };
+    const fn = { kind: "dynFrom", value: v, type: DYN, loc };
+    // flatMap over a compiled generator: the runtime steps it through the
+    // helpers over its type
+    if (member === "flatMap" && v.type.ret.kind === "generator")
+        return { fn, takesOptions, gen: v.type.ret };
+    return { fn, takesOptions };
+}
+/** The operator callbacks' `{ signal }` (operators.js): map and the
+ * operators over it pass `{ signal: AbortSignal.any([options?.signal]
+ * .filter(Boolean)) }`. options is the operator's options value. */
+export function operatorSignalOptions(lowerer, options, loc) {
+    void lowerer;
+    const list = {
+        kind: "libCall",
+        fn: "readable.opSignalList",
+        args: [options],
+        type: DYN,
+        loc,
+    };
+    const signal = { kind: "libCall", fn: "fetch.abortAny", 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
+ * = new AbortController()`, `options.signal.addEventListener('abort', ()
+ * => ac.abort(), { once: true })`, then reduceSignal's ac.abort() closure
+ * and `{ signal: ac.signal }`. options is the bound options value. */
+export function reduceSignalSetup(lowerer, options, loc, declare = (name, type) => lowerer.declareHiddenLocal(name, type)) {
+    const acLocal = declare("%opAbort", DYN);
+    const ac = varRef(acLocal.id, DYN, loc);
+    const sigLocal = declare("%opUserSignal", DYN);
+    const sig = varRef(sigLocal.id, DYN, loc);
+    const abort = pipelineAbortHelper(lowerer, ac, loc);
+    const stmts = [
+        {
+            kind: "varDecl",
+            localId: acLocal.id,
+            init: { kind: "libCall", fn: "fetch.abortControllerNew", args: [], type: DYN, loc },
+            loc,
+        },
+        {
+            kind: "varDecl",
+            localId: sigLocal.id,
+            init: { kind: "libCall", fn: "readable.opSignalOf", args: [options], type: DYN, loc },
+            loc,
+        },
+        {
+            kind: "if",
+            cond: { kind: "dynTest", test: "truthy", value: sig, type: BOOL, loc },
+            then: [
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "dynInvoke",
+                        recv: sig,
+                        method: "addEventListener",
+                        calleeName: "options.signal.addEventListener",
+                        args: [
+                            { kind: "dynFrom", value: strLit("abort", loc), type: DYN, loc },
+                            { kind: "dynFrom", value: pipelineAbortHelper(lowerer, ac, loc), type: DYN, loc },
+                            { kind: "libCall", fn: "readable.opOnceOptions", args: [], type: DYN, loc },
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            else_: null,
+            loc,
+        },
+    ];
+    const signal = {
+        kind: "dynKeyGet",
+        value: ac,
+        key: strLit("signal", loc),
+        type: DYN,
+        loc,
+    };
+    return {
+        stmts,
+        abort,
+        cbOpts: { kind: "libCall", fn: "readable.opSignalOpts", args: [signal], type: DYN, loc },
+    };
 }
 /** An operator's options (or reduce's initial value): an object literal
  * becomes a checked-dynamic object, checked-dynamic values pass through,
@@ -2654,21 +4237,37 @@ function lowerOperatorValue(lowerer, node, what, loc, literalObject) {
 function lowerStreamOperator(lowerer, call, access, member) {
     const loc = locOf(call);
     const args = call.arguments.nodes;
-    const recv = lowerer.lowerExpr(access.expression);
+    // JS order: the receiver, the callback, then the options; the
+    // callback's { signal } is built over the options value afterwards.
+    const decls = [];
+    const bind = (value, name) => {
+        const local = lowerer.declareHiddenLocal(name, value.type);
+        decls.push({ kind: "varDecl", localId: local.id, init: value, loc });
+        return varRef(local.id, value.type, loc);
+    };
+    const recv = bind(streamReceiverExpr(lowerer, access.expression), "%opRecv");
     const readable = { kind: "object", className: "%Readable" };
     const opts = (i) => lowerOperatorValue(lowerer, args[i], `${member} options`, loc, true);
+    let takesOptions = false;
+    let callbackGen;
     const fnArg = (maxParams) => {
         if (args[0] === undefined)
             return dynUndefinedExpr(loc);
-        return lowerOperatorCallback(lowerer, args[0], member, maxParams);
+        const lowered = lowerOperatorCallback(lowerer, args[0], member, maxParams);
+        takesOptions = lowered.takesOptions;
+        callbackGen = lowered.gen;
+        return bind(lowered.fn, "%opFn");
+    };
+    const lib = (fn, a, type) => {
+        const call = { kind: "libCall", fn: fn, args: a, type, loc };
+        return { kind: "seqExpr", stmts: decls, result: call, type, loc };
+    };
+    // the options argument (bound), and the callback's { signal } when it
+    // declares one
+    const withSignal = (optsValue) => {
+        const o = bind(optsValue, "%opOptions");
+        return [o, takesOptions ? operatorSignalOptions(lowerer, o, loc) : dynUndefinedExpr(loc)];
     };
-    const lib = (fn, a, type) => ({
-        kind: "libCall",
-        fn: fn,
-        args: a,
-        type,
-        loc,
-    });
     switch (member) {
         case "map":
         case "filter":
@@ -2679,7 +4278,12 @@ function lowerStreamOperator(lowerer, call, access, member) {
                 : member === "filter"
                     ? "readable.opFilter"
                     : "readable.opFlatMap";
-            return lib(fnName, [recv, fn, opts(1)], readable);
+            const rest = withSignal(opts(1));
+            const genHelpers = callbackGen ? fromGenHelpers(lowerer, callbackGen, loc) : null;
+            if (callbackGen && genHelpers) {
+                return lib(callbackGen.async ? "readable.opFlatMapAsyncGen" : "readable.opFlatMapSyncGen", [recv, fn, ...rest, ...genHelpers], readable);
+            }
+            return lib(fnName, [recv, fn, ...rest], readable);
         }
         case "drop":
         case "take": {
@@ -2688,12 +4292,17 @@ function lowerStreamOperator(lowerer, call, access, member) {
         }
         case "toArray":
             return lib("readable.opToArray", [recv, opts(0)], { kind: "promise", inner: DYN });
-        case "forEach":
-            return lib("readable.opForEach", [recv, fnArg(1), opts(1)], { kind: "promise", inner: VOID });
+        case "forEach": {
+            const fn = fnArg(1);
+            return lib("readable.opForEach", [recv, fn, ...withSignal(opts(1))], {
+                kind: "promise",
+                inner: VOID,
+            });
+        }
         case "some":
         case "every": {
             const fn = fnArg(1);
-            return lib(member === "some" ? "readable.opSome" : "readable.opEvery", [recv, fn, opts(1)], {
+            return lib(member === "some" ? "readable.opSome" : "readable.opEvery", [recv, fn, ...withSignal(opts(1))], {
                 kind: "promise",
                 inner: BOOL,
             });
@@ -2704,7 +4313,11 @@ function lowerStreamOperator(lowerer, call, access, member) {
             if (inner && !(inner.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))) {
                 lowerer.noLowering("find with a type-guard callback", call, "the result is a checked-dynamic value — use a boolean predicate and narrow the result");
             }
-            return lib("readable.opFind", [recv, fnArg(1), opts(1)], { kind: "promise", inner: DYN });
+            const fn = fnArg(1);
+            return lib("readable.opFind", [recv, fn, ...withSignal(opts(1))], {
+                kind: "promise",
+                inner: DYN,
+            });
         }
         case "reduce": {
             const t = lowerer.typeOf(call);
@@ -2730,20 +4343,21 @@ function lowerStreamOperator(lowerer, call, access, member) {
                 }
             }
             const fn = fnArg(2);
-            const init = lowerOperatorValue(lowerer, args[1], "reduce's initial value", loc, false);
-            return lib("readable.opReduce", [recv, fn, init, boolLit(args.length >= 2, loc), opts(2), numLit(kind, loc)], { kind: "promise", inner });
+            const init = bind(lowerOperatorValue(lowerer, args[1], "reduce's initial value", loc, false), "%opInit");
+            const o = bind(opts(2), "%opOptions");
+            const head = [recv, fn, init, boolLit(args.length >= 2, loc), o, numLit(kind, loc)];
+            if (!takesOptions)
+                return lib("readable.opReduce", head, { kind: "promise", inner });
+            const setup = reduceSignalSetup(lowerer, o, loc);
+            decls.push(...setup.stmts);
+            return lib("readable.opReduceSignal", [...head, setup.abort, setup.cbOpts], {
+                kind: "promise",
+                inner,
+            });
         }
     }
     throw new InternalCompilerError(`unknown stream operator ${member}`);
 }
-/** The literal 'buffer' encoding on write()/end(): Node 24 takes it for a
- * Buffer chunk and throws ERR_UNKNOWN_ENCODING for a string chunk. */
-function isBufferEncoding(lowerer, arg) {
-    if (arg === undefined)
-        return false;
-    const t = lowerer.typeOf(arg);
-    return t.isStringLiteralType() && t.value === "buffer";
-}
 /** The one supported encoding argument: utf8 (Node's default), as a
  * compile-time literal or absent. */
 function checkUtf8Encoding(lowerer, member, arg) {
@@ -2779,7 +4393,7 @@ function pipeEndOption(lowerer, options, loc) {
 function pipeIntoStdio(lowerer, call, access, target) {
     const loc = locOf(call);
     // JS order: the receiver, then the destination, then the options.
-    const receiverValue = lowerer.lowerExpr(access.expression);
+    const receiverValue = streamReceiverExpr(lowerer, access.expression);
     const source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type);
     const stdio = lowerer.declareHiddenLocal("%pipeStdio", target.type);
     const options = call.arguments.nodes[1];
@@ -2890,7 +4504,7 @@ function generalPipe(lowerer, dst) {
 function pipeIntoDyn(lowerer, call, access, target) {
     const loc = locOf(call);
     noteUntypedStreamFlow(lowerer, null);
-    const receiverValue = lowerer.lowerExpr(access.expression);
+    const receiverValue = streamReceiverExpr(lowerer, access.expression);
     const source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type);
     const destination = lowerer.declareHiddenLocal("%pipeDestination", target.type);
     const stmts = [
@@ -2976,6 +4590,59 @@ function pipeIntoDyn(lowerer, call, access, target) {
         loc,
     };
 }
+/** readable.compose(stage, options): compose(this, stage), with
+ * addAbortSignal(options.signal, composed) when the signal is set
+ * (operators.js). */
+function lowerReadableCompose(lowerer, call, access) {
+    const loc = locOf(call);
+    const args = call.arguments.nodes;
+    if (args.length === 0 || args.length > 2 || args.some((a) => ts.isSpreadElement(a))) {
+        lowerer.noLowering(`readable.compose with ${args.length === 0 ? "no stage" : "these arguments"}`, call, "the supported form is readable.compose(stage) or readable.compose(stage, { signal })");
+    }
+    let signalNode = null;
+    const options = args[1];
+    if (options !== undefined &&
+        options.kind !== ts.SyntaxKind.NullKeyword &&
+        !(ts.isIdentifier(options) && options.text === "undefined")) {
+        if (!ts.isObjectLiteralExpression(options)) {
+            lowerer.noLowering("readable.compose options that are not an object literal", options, "pass { signal } as an object literal");
+        }
+        for (const p of options.properties.nodes) {
+            const key = (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+                ts.isIdentifier(p.name)
+                ? p.name.text
+                : null;
+            if (key !== "signal") {
+                lowerer.noLowering(key === null
+                    ? "readable.compose options with this member"
+                    : `the readable.compose option '${key}'`, p, "signal is the readable.compose option");
+            }
+            const value = ts.isShorthandPropertyAssignment(p)
+                ? p.name
+                : p.initializer;
+            if (value.kind === ts.SyntaxKind.NullKeyword)
+                continue;
+            if (ts.isIdentifier(value) && value.text === "undefined")
+                continue;
+            // The signal is read after compose runs, so only values whose
+            // evaluation has no effects.
+            if (!sideEffectFreeOptionValue(value) && !pureRead(value)) {
+                lowerer.noLowering("the readable.compose option 'signal' with this value", p, "pass a variable or property read (const signal = controller.signal)");
+            }
+            signalNode = value;
+        }
+    }
+    const composed = lowerStreamCompose(lowerer, [access.expression, args[0]], loc);
+    if (signalNode === null)
+        return composed;
+    return {
+        kind: "libCall",
+        fn: "stream.addAbortSignal",
+        args: [composed, lowerer.lowerExprExpecting(signalNode, DYN)],
+        type: composed.type,
+        loc,
+    };
+}
 export function lowerStreamMethodCall(lowerer, call, access, info) {
     const member = access.name.text;
     if (STREAM_OPERATORS.has(member)) {
@@ -2983,6 +4650,12 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         if (opSides === "r" || opSides === "rw")
             return lowerStreamOperator(lowerer, call, access, member);
     }
+    if (member === "compose") {
+        const composeSides = streamSidesOf(lowerer, info);
+        return composeSides === "r" || composeSides === "rw"
+            ? lowerReadableCompose(lowerer, call, access)
+            : null;
+    }
     if (!STREAM_API_MEMBERS.has(member))
         return null;
     const sides = streamSidesOf(lowerer, info);
@@ -3037,7 +4710,16 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             if (probed?.type.kind === "nullT")
                 return "null";
         }
-        lowerer.noLowering(`${member} with a '${t ? lowerer.fmt(t) : "?"}' chunk`, node, "chunks are Buffers or utf8 strings — or unions of those with null (objectMode is not lowered)");
+        // Any other value is a checked-dynamic chunk: one entry on an
+        // object-mode side, Node's chunk type error on a byte-mode one
+        // (undefined, which a byte-mode push ignores, included).
+        if (t?.kind === "void" || t?.kind === "undefinedT")
+            return "dyn";
+        if (t !== null &&
+            t.kind !== "func" &&
+            canConvertToDyn(t, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+            return "dyn";
+        lowerer.noLowering(`${member} with a '${t ? lowerer.fmt(t) : "?"}' chunk`, node, "chunks are values that convert to checked-dynamic values: Buffers, strings, numbers, records, arrays and class instances");
     };
     if (member === "push" || member === "unshift") {
         requireSide(readableSide, member);
@@ -3056,7 +4738,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 if (canonical === undefined) {
                     return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", `Unknown encoding: ${t.value}`, BOOL, loc);
                 }
-                const receiver = lowerer.lowerExpr(access.expression);
+                const receiver = streamReceiverExpr(lowerer, access.expression);
                 const chunk = lowerer.lowerExprExpecting(args[0], STRING);
                 return {
                     kind: "libCall",
@@ -3070,9 +4752,19 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         checkUtf8Encoding(lowerer, member, args[1]);
         const kind = chunkKind(args[0]);
         if ((kind === "null" || kind === "union" || kind === "dyn") && member === "unshift") {
-            lowerer.noLowering(kind === "null" ? "unshift(null)" : "unshift with a nullable or dynamic chunk", call, "EOF signals through push(null)");
+            // unshift(value): an object-mode stream's value at the front, null
+            // the end of the stream, as Node's readableAddChunk takes them
+            const receiver = streamReceiverExpr(lowerer, access.expression);
+            const chunk = lowerer.lowerExprExpecting(args[0], DYN);
+            return {
+                kind: "libCall",
+                fn: "readable.unshiftDyn",
+                args: [receiver, chunk],
+                type: VOID,
+                loc,
+            };
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         if (kind === "null") {
             return { kind: "libCall", fn: "readable.pushNull", args: [receiver], type: BOOL, loc };
         }
@@ -3123,7 +4815,21 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         requireSide(readableSide, "read");
         if (args.length > 1)
             lowerer.noLowering(`read with ${args.length} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
+        // JavaScript (and a result the declarations type as any) reads any
+        // chunk: a Buffer, a string once encoded, or an object-mode value.
+        const resultTs = lowerer.typeOf(call);
+        if (isJsSourceFile(ts.getSourceFileOfNode(call)) ||
+            (resultTs.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+            const sizeDyn = args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc);
+            return {
+                kind: "libCall",
+                fn: "readable.readDyn",
+                args: [receiver, sizeDyn],
+                type: DYN,
+                loc,
+            };
+        }
         const size = args[0] ? lowerer.lowerExprExpecting(args[0], F64) : numLit(-1, loc);
         const type = unionOf(lowerer, [BYTES, { kind: "nullT" }]);
         const read = {
@@ -3139,7 +4845,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         requireSide(readableSide, member);
         if (args.length !== 0)
             lowerer.noLowering(`${member} with arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         return {
             kind: "libCall",
             fn: member === "pause" ? "readable.pause" : "readable.resume",
@@ -3152,7 +4858,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         requireSide(readableSide, "isPaused");
         if (args.length !== 0)
             lowerer.noLowering(`isPaused with arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         return { kind: "libCall", fn: "readable.isPaused", args: [receiver], type: BOOL, loc };
     }
     if (member === "pipe") {
@@ -3160,10 +4866,11 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         if (args.length === 0 || args.length > 2) {
             lowerer.noLowering(`pipe with ${args.length} arguments`, call, "the supported forms are (destination) and (destination, { end })");
         }
-        // A Hash or Hmac destination pipes into its Transform, and pipe()
-        // answers the Hash itself (the receiver evaluates first, as in JS).
-        if (isHashValueType(lowerer.mapTypeOf(lowerer.typeOf(args[0])))) {
-            const receiverValue = lowerer.lowerExpr(access.expression);
+        // A Hash, Hmac, Cipheriv or Decipheriv destination pipes into its
+        // Transform, and pipe() answers the value itself (the receiver
+        // evaluates first, as in JS).
+        if (isValueStream(lowerer, args[0])) {
+            const receiverValue = streamReceiverExpr(lowerer, access.expression);
             const source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type);
             const hashValue = lowerer.lowerExpr(args[0]);
             const hash = lowerer.declareHiddenLocal("%pipeHash", hashValue.type);
@@ -3180,7 +4887,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                             fn: "readable.pipe",
                             args: [
                                 { kind: "varRef", localId: source.id, type: receiverValue.type, loc },
-                                hashStreamOf({ kind: "varRef", localId: hash.id, type: hashValue.type, loc }, true),
+                                valueStreamOf({ kind: "varRef", localId: hash.id, type: hashValue.type, loc }, true),
                                 end,
                             ],
                             type: { kind: "object", className: "%Transform" },
@@ -3207,7 +4914,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             lowerer.noLowering(`pipe into a '${lowerer.fmt(dst.type)}'`, args[0], "the destination must be a stream Writable/Duplex, process.stdout or process.stderr (sockets are not pipe destinations yet)");
         }
         const end = pipeEndOption(lowerer, args[1], loc);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         return {
             kind: "libCall",
             fn: generalPipe(lowerer, dst.type),
@@ -3220,7 +4927,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         requireSide(readableSide, "unpipe");
         if (args.length > 1)
             lowerer.noLowering(`unpipe with ${args.length} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         if (args[0] !== undefined) {
             const dst = lowerer.lowerExpr(args[0]);
             if (dst.type.kind === "dyn")
@@ -3281,7 +4988,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
     if (member === "destroy") {
         if (args.length > 1)
             lowerer.noLowering(`destroy with ${args.length} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         if (args[0] !== undefined) {
             const err = lowerer.lowerExpr(args[0]);
             const rootsAtError = (t) => {
@@ -3314,10 +5021,51 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         const kind = chunkKind(args[0]);
         if (kind === "null")
             lowerer.noLowering("write(null)", call, "end() finishes a writable");
+        const lowerWriteCb = (cbArg) => {
+            const cb = callbackDeclaresParameters(cbArg)
+                ? null
+                : lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
+            if (cb === null || cb.type.kind !== "func" || cb.type.params.length > 0) {
+                lowerer.noLowering("write completion callbacks taking the error argument", cbArg, "() => void callbacks are supported (listen for 'error' to observe failures)");
+            }
+            return cb;
+        };
+        // write(chunk, encoding[, cb]), and write(value, cb): the encoding
+        // argument reaches an object-mode side's _write as passed, null when
+        // the callback took its place (a byte-mode side encodes a string
+        // chunk with it).
+        const writeEnc = (encArg, cbArg) => {
+            const receiver = streamReceiverExpr(lowerer, access.expression);
+            const chunk = lowerer.lowerExprExpecting(args[0], DYN);
+            const tail = [];
+            if (encArg !== undefined)
+                tail.push(lowerer.lowerExprExpecting(encArg, DYN));
+            if (cbArg !== undefined)
+                tail.push(lowerWriteCb(cbArg));
+            const flags = (encArg !== undefined ? 1 : 0) | (cbArg !== undefined ? 2 : 0);
+            return {
+                kind: "libCall",
+                fn: "writable.writeEnc",
+                args: [receiver, numLit(flags, loc), chunk, ...tail],
+                type: BOOL,
+                loc,
+            };
+        };
         if (kind === "dyn") {
-            if (args.length > 1)
-                lowerer.noLowering("write with a dynamic chunk and more arguments", call);
-            const receiver = lowerer.lowerExpr(access.expression);
+            if (args.length === 3)
+                return writeEnc(args[1], args[2]);
+            if (args.length === 2) {
+                // Node's write takes a function there as the callback, anything
+                // else as the encoding
+                const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
+                if (t?.kind === "func")
+                    return writeEnc(undefined, args[1]);
+                if (t === null || t === undefined || t.kind === "dyn") {
+                    lowerer.noLowering("write with a dynamic second argument", args[1], "pass an encoding string or a completion callback");
+                }
+                return writeEnc(args[1], undefined);
+            }
+            const receiver = streamReceiverExpr(lowerer, access.expression);
             const chunk = lowerer.lowerExprExpecting(args[0], DYN);
             return { kind: "libCall", fn: "writable.writeDyn", args: [receiver, chunk], type: BOOL, loc };
         }
@@ -3328,7 +5076,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             // re-dispatch on its IR type.
             if (args.length > 1)
                 lowerer.noLowering("write with a union chunk and more arguments", call);
-            const receiver = lowerer.lowerExpr(access.expression);
+            const receiver = streamReceiverExpr(lowerer, access.expression);
             const chunk = lowerer.lowerExpr(args[0]);
             const fn = chunk.type.kind === "union"
                 ? "writable.writeU"
@@ -3340,36 +5088,24 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             return { kind: "libCall", fn, args: [receiver, chunk], type: BOOL, loc };
         }
         // Disambiguate (chunk, cb?) vs (chunk, encoding, cb?) by the second
-        // argument's static type.
+        // argument's static type. A write with an encoding runs through
+        // writeEnc, whose runtime checks and applies it as Node's _write does.
         let cbArg;
-        if (args.length >= 2 && isBufferEncoding(lowerer, args[1])) {
-            if (kind !== "bytes")
-                return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", "Unknown encoding: buffer", BOOL, loc);
-            cbArg = args[2];
-        }
-        else if (args.length === 2) {
+        if (args.length === 3)
+            return writeEnc(args[1], args[2]);
+        if (args.length === 2) {
             const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
-            if (t?.kind === "string")
-                checkUtf8Encoding(lowerer, "write", args[1]);
-            else
-                cbArg = args[1];
-        }
-        else if (args.length === 3) {
-            checkUtf8Encoding(lowerer, "write", args[1]);
-            cbArg = args[2];
+            if (t?.kind === "string" || t?.kind === "nullT" || t?.kind === "undefinedT")
+                return writeEnc(args[1], undefined);
+            cbArg = args[1];
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         const chunk = kind === "bytes"
             ? lowerer.lowerExprExpecting(args[0], BYTES)
             : lowerer.lowerExprExpecting(args[0], STRING);
         const fn = kind === "bytes" ? "writable.write" : "writable.writeStr";
         if (cbArg !== undefined) {
-            const cb = callbackDeclaresParameters(cbArg)
-                ? null
-                : lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
-            if (cb === null || cb.type.kind !== "func" || cb.type.params.length > 0) {
-                lowerer.noLowering("write completion callbacks taking the error argument", cbArg, "() => void callbacks are supported (listen for 'error' to observe failures)");
-            }
+            const cb = lowerWriteCb(cbArg);
             return { kind: "libCall", fn, args: [receiver, chunk, cb], type: BOOL, loc };
         }
         return { kind: "libCall", fn, args: [receiver, chunk], type: BOOL, loc };
@@ -3381,6 +5117,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         // Forms: (), (cb), (chunk), (chunk, cb), (chunk, encoding, cb).
         let chunkNode;
         let cbArg;
+        let encNode;
         if (args.length === 1) {
             const t = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
             if (t?.kind === "func")
@@ -3388,35 +5125,26 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             else
                 chunkNode = args[0];
         }
-        else if (args.length >= 2 && isBufferEncoding(lowerer, args[1])) {
-            chunkNode = args[0];
-            const endKind = chunkKind(args[0]);
-            if (endKind === "string") {
-                const endT = lowerer.mapTypeOf(lowerer.typeOf(call)) ?? DYN;
-                return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", "Unknown encoding: buffer", endT, loc);
-            }
-            if (endKind !== "bytes")
-                checkUtf8Encoding(lowerer, "end", args[1]);
-            cbArg = args[2];
-        }
         else if (args.length === 2) {
             chunkNode = args[0];
             const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
-            if (t?.kind === "string")
-                checkUtf8Encoding(lowerer, "end", args[1]);
+            if (t?.kind === "string" || t?.kind === "nullT" || t?.kind === "undefinedT")
+                encNode = args[1];
             else
                 cbArg = args[1];
         }
         else if (args.length === 3) {
             chunkNode = args[0];
-            checkUtf8Encoding(lowerer, "end", args[1]);
+            encNode = args[1];
             cbArg = args[2];
         }
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         let flags = 0;
         const tail = [];
         if (chunkNode !== undefined) {
-            const kind = chunkKind(chunkNode);
+            // end(chunk, encoding[, cb]) writes the chunk with the encoding
+            // argument as passed (flags 16), through the dyn write
+            const kind = encNode !== undefined ? "dyn" : chunkKind(chunkNode);
             if (kind === "null" || kind === "union")
                 lowerer.noLowering("end(null)", call);
             flags |= kind === "bytes" ? 1 : kind === "dyn" ? 8 : 2;
@@ -3425,6 +5153,10 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 : kind === "dyn"
                     ? lowerer.lowerExprExpecting(chunkNode, DYN)
                     : lowerer.lowerExprExpecting(chunkNode, STRING));
+            if (encNode !== undefined) {
+                flags |= 16;
+                tail.push(lowerer.lowerExprExpecting(encNode, DYN));
+            }
         }
         if (cbArg !== undefined) {
             const cb = callbackDeclaresParameters(cbArg)
@@ -3448,7 +5180,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         requireSide(writableSide, member);
         if (args.length !== 0)
             lowerer.noLowering(`${member} with arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         return {
             kind: "libCall",
             fn: member === "cork" ? "writable.cork" : "writable.uncork",
@@ -3463,7 +5195,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             lowerer.noLowering(`setEncoding with ${args.length} arguments`, call, "one literal encoding is the supported form");
         }
         const enc = bufEncoding(lowerer, "setEncoding", args[0]);
-        const receiver = lowerer.lowerExpr(access.expression);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
         return {
             kind: "libCall",
             fn: "readable.setEncoding",
@@ -3473,14 +5205,20 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         };
     }
     if (member === "setDefaultEncoding") {
-        // The write-side default: utf8 IS the default — admit it; other
-        // encodings would change what write(string) means.
+        // The write-side default: lowercased and validated (ERR_UNKNOWN_ENCODING,
+        // thrown) at run time; answers the stream.
         requireSide(writableSide, "setDefaultEncoding");
-        const t = args[0] ? lowerer.typeOf(args[0]) : null;
-        if (t?.isStringLiteralType() && (t.value === "utf8" || t.value === "utf-8")) {
-            return lowerer.lowerExpr(access.expression);
-        }
-        lowerer.noLowering("setDefaultEncoding", call, "utf8 (the default, as a compile-time literal) is the supported write-side string encoding");
+        if (args.length > 1)
+            lowerer.noLowering(`setDefaultEncoding with ${args.length} arguments`, call);
+        const receiver = streamReceiverExpr(lowerer, access.expression);
+        const enc = args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc);
+        return {
+            kind: "libCall",
+            fn: "writable.setDefaultEncoding",
+            args: [receiver, enc],
+            type: receiver.type,
+            loc,
+        };
     }
     return null;
 }
@@ -3613,7 +5351,7 @@ export function lowerStreamProperty(lowerer, expr, info) {
     const propCall = (type) => ({
         kind: "libCall",
         fn: "stream.prop",
-        args: [lowerer.lowerExpr(expr.expression), strLit(name, loc)],
+        args: [streamReceiverExpr(lowerer, expr.expression), strLit(name, loc)],
         type,
         loc,
     });
@@ -3631,7 +5369,7 @@ export function lowerStreamProperty(lowerer, expr, info) {
         const read = {
             kind: "libCall",
             fn: "readable.flowing",
-            args: [lowerer.lowerExpr(expr.expression)],
+            args: [streamReceiverExpr(lowerer, expr.expression)],
             type,
             loc,
         };
@@ -3645,7 +5383,7 @@ export function lowerStreamProperty(lowerer, expr, info) {
         const read = {
             kind: "libCall",
             fn: "stream.errored",
-            args: [lowerer.lowerExpr(expr.expression)],
+            args: [streamReceiverExpr(lowerer, expr.expression)],
             type,
             loc,
         };
@@ -3656,8 +5394,7 @@ export function lowerStreamProperty(lowerer, expr, info) {
         return propCall(BOOL);
     }
     if (name === "writableObjectMode" && writableSide) {
-        // objectMode construction fences, so the answer is compile-time false.
-        return boolLit(false, loc);
+        return propCall(BOOL);
     }
     if (name === "allowHalfOpen" && sides === "rw") {
         return propCall(BOOL);