@scriptc/compiler 0.4.2 → 0.4.4

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

@@ -48,6 +48,7 @@ import { bindingNeverReassigned } from "./binding-analysis.js";
 import { extractIteratorValue, genStep, genValue, stepDrivable } from "./lower-generators.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,
@@ -70,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) {
@@ -135,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],
@@ -256,9 +319,11 @@ function lowerStreamCallback(lowerer, which, node, thisType, fullTuple, chunkVal
         // 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))) ||
+        if (((((i === 0 &&
+            (chunkValues || widensInto(lowerer, fullTuple[0], funcType.params[0], loc))) ||
             i === 1) &&
-            (which === "write" || which === "transform") &&
+            (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;
@@ -359,14 +424,20 @@ function streamObjectModes(lowerer, ctorName, optsLit) {
     }
     return out;
 }
-/** Whether an options literal sets the writable side's object mode with a
- * `true` literal (objectMode, or writableObjectMode on a duplex stream).
- * Reports nothing: streamObjectModes fences the other value forms. */
+/** 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)
@@ -384,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"],
@@ -577,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, 
@@ -601,11 +721,19 @@ 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)) {
@@ -617,6 +745,22 @@ fallbackCb) {
     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)
@@ -634,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;
@@ -659,6 +803,7 @@ fallbackCb) {
             }
             const full = tuples[name].map((t) => (t === "fn" ? null : t));
             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
@@ -673,11 +818,22 @@ fallbackCb) {
                     }
                     return declared ?? funcOf([], VOID);
                 });
-                present.set(name, lowerStreamCallback(lowerer, name, fnNode, thisType, tuple, out.writableObject));
+                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;
         }
@@ -720,9 +876,29 @@ fallbackCb) {
                 // 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": {
@@ -758,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)`:
@@ -813,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);
@@ -833,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
@@ -859,10 +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) {
@@ -906,6 +1173,18 @@ export function lowerStreamNew(lowerer, expr, info) {
             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).
@@ -928,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). */
@@ -1000,9 +1307,11 @@ 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.
-            if (i === 1 &&
-                (which === "write" || which === "transform") &&
+            // 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);
@@ -1019,8 +1328,7 @@ function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, bl
             // 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 &&
-                chunkValues &&
-                (which === "write" || which === "transform") &&
+                (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);
@@ -1113,7 +1421,7 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
         (!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, chunkValues)
             : null;
@@ -1134,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",
@@ -1146,6 +1462,7 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
                     },
                     loc,
                 },
+                ...streamOptionFollowUps({ decodeStringsOff: false, writeEncoding: null, extras }, thisRef, thisType, loc, "stream.setWritevDefault"),
             ];
         }
     }
@@ -1162,6 +1479,7 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
         ];
     }
     const out = [
+        ...parsed.valueDecls,
         {
             kind: "exprStmt",
             expr: {
@@ -1187,6 +1505,20 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
             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",
@@ -1226,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 ─────────────────────────── */
@@ -1269,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;
@@ -1307,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",
@@ -1364,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.
@@ -1473,13 +1950,15 @@ 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, Maps, generators and class iterables of values that convert to checked-dynamic values");
+    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 can be stream chunks: values that box
  * into checked-dynamic values (null included: the runtime destroys the
@@ -1960,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
@@ -2159,18 +2656,28 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
                 : null;
             const stageArgs = opts ? args.slice(0, -1) : args;
             if (hasPipelineFunctionStage(lowerer, stageArgs)) {
-                if (opts) {
-                    lowerer.noLowering("pipeline with function stages or iterable sources and options", lastArg, "pipeline(source, async function* (source) { ... }, destination) without options is supported");
-                }
                 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 {
@@ -2328,18 +2835,28 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
         }
         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,
                 });
@@ -2372,8 +2889,12 @@ 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;
 }
 /** The function a pipeline() argument writes or names, or null when the
@@ -2424,6 +2945,9 @@ function hasPipelineFunctionStage(lowerer, args) {
 function iterableSourceType(lowerer, node) {
     if (pipelineStageFunction(lowerer, node) !== null)
         return null;
+    const webElem = staticReadableStreamElementType(lowerer, node);
+    if (webElem !== null)
+        return webElem;
     let t;
     try {
         t = lowerer.mapTypeOf(lowerer.typeOf(node));
@@ -2446,7 +2970,229 @@ function iterableSourceType(lowerer, node) {
  * 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) {
@@ -2563,13 +3309,14 @@ function lowerIterableSource(lowerer, node, fn, loc) {
 /** 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), 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. Each stage's `source` parameter is typed as what the
+ * 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) {
+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");
     }
@@ -2589,13 +3336,16 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
     const argOrder = [];
     for (let j = 0; j < stageArgs.length; j++) {
         const arg = stageArgs[j];
-        const fn = pipelineStageFunction(lowerer, arg);
+        // 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 && (syncSourceFn || (fn === null && iterableSourceType(lowerer, arg) !== null))) {
+        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);
@@ -2618,7 +3368,7 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
             }
             let stream;
             try {
-                stream = lowerStreamArg(lowerer, arg, "pipeline");
+                stream = preLowered?.get(j) ?? lowerStreamArg(lowerer, arg, "pipeline");
             }
             catch (e) {
                 if (e instanceof StreamArgTypeThrow)
@@ -2633,11 +3383,6 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
         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 (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", arg, "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"
@@ -2665,6 +3410,16 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
             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;
         }
@@ -2690,7 +3445,8 @@ function lowerPipelineStages(lowerer, stageArgs, 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.
+    // 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),
@@ -2702,7 +3458,7 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
         ...stages,
         ...helperArgs,
     ];
-    const last = dest === 2 ? { 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: bindArgs };
     // const ac = new AbortController(): its signal goes to the stages, and
@@ -2765,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 = 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",
@@ -2788,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,
                     },
@@ -2890,6 +3647,328 @@ function lowerStageFunction(lowerer, fn, srcT) {
         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) {
@@ -2905,18 +3984,51 @@ function stageChunkCheckerType(lowerer, chunk, at) {
  * 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)
@@ -2948,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",
@@ -2961,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,
@@ -3028,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":
@@ -3053,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": {
@@ -3062,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,
             });
@@ -3078,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);
@@ -3104,8 +4343,17 @@ 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}`);
@@ -3145,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];
@@ -3256,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 = [
@@ -3342,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)) {
@@ -3349,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);
@@ -3431,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",
@@ -3447,7 +4754,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         if ((kind === "null" || kind === "union" || kind === "dyn") && member === "unshift") {
             // 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 = lowerer.lowerExpr(access.expression);
+            const receiver = streamReceiverExpr(lowerer, access.expression);
             const chunk = lowerer.lowerExprExpecting(args[0], DYN);
             return {
                 kind: "libCall",
@@ -3457,7 +4764,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 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 };
         }
@@ -3508,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 = {
@@ -3524,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",
@@ -3537,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") {
@@ -3549,7 +4870,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         // Transform, and pipe() answers the value itself (the receiver
         // evaluates first, as in JS).
         if (isValueStream(lowerer, args[0])) {
-            const receiverValue = lowerer.lowerExpr(access.expression);
+            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);
@@ -3593,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),
@@ -3606,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")
@@ -3667,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) => {
@@ -3714,7 +5035,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         // the callback took its place (a byte-mode side encodes a string
         // chunk with it).
         const writeEnc = (encArg, cbArg) => {
-            const receiver = lowerer.lowerExpr(access.expression);
+            const receiver = streamReceiverExpr(lowerer, access.expression);
             const chunk = lowerer.lowerExprExpecting(args[0], DYN);
             const tail = [];
             if (encArg !== undefined)
@@ -3744,7 +5065,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 }
                 return writeEnc(args[1], undefined);
             }
-            const receiver = lowerer.lowerExpr(access.expression);
+            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 };
         }
@@ -3755,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"
@@ -3778,7 +5099,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 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);
@@ -3817,7 +5138,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             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) {
@@ -3859,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",
@@ -3874,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",
@@ -3884,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;
 }
@@ -4024,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,
     });
@@ -4042,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,
         };
@@ -4056,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,
         };