@scriptc/compiler 0.3.5 → 0.4.0

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

@@ -1,4 +1,5 @@
 import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.js";
+import { hashStreamOf, isHashValueType } from "./builtins/hash-stream.js";
 import { InternalCompilerError } from "../../errors.js";
 /* The node:stream lowering (the spoke-module pattern, like
  * lower-event-emitter.ts): construction of the five runtime stream classes
@@ -30,6 +31,7 @@ import { InternalCompilerError } from "../../errors.js";
  * its Node signature (the emitter listener rule). */
 import * as ts from "../ts7/adapter.js";
 import { dynFallbackType } from "./lowerer.js";
+import { accessorCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, } from "./lower-classes.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { newFnCtx, own } from "./lowerer.js";
 import { appendImplicitUndefinedReturn } from "./function-returns.js";
@@ -39,6 +41,8 @@ import { sideEffectFreeOptionValue } from "./surfaces.js";
 import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { dynUndefinedExpr, varRef } from "../../ir/build.js";
 import { genResultRecord } from "../type-mapper.js";
+import { noteUntypedStreamFlow, requestGeneralStreamSurface } from "./general-streams.js";
+import { dynNativeBranch } from "./dyn-streams.js";
 import { extractIteratorValue, genStep, genValue, stepDrivable } from "./lower-generators.js";
 import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, BYTES_U8, canBoxFuncIntoDyn, canConvertToDyn, funcOf, typeEquals, typeKey, } from "../../ir/ir.js";
 const BYTES = BYTES_U8;
@@ -127,6 +131,15 @@ export const UNDERSCORE_METHODS = new Map([
     ["transform", "_transform"],
     ["flush", "_flush"],
 ]);
+/** 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],
+    ["_final", 0],
+    ["_destroy", 1],
+    ["_transform", 2],
+    ["_flush", 0],
+]);
 /** The accepted option-callback names (canonical flag order) and the
  * duplex-shaped-head answer for one runtime stream class. */
 export function streamCtorShape(cls) {
@@ -161,6 +174,7 @@ export const STREAM_FORCED_EVENT_NAMES = new Set([
     "unpipe",
     "open",
     "ready",
+    "keypress",
 ]);
 /** The per-base FORCED event tuples (runtime-emitted payloads): consulted
  * by the emitter spoke BEFORE the program-global table, so a stream's
@@ -181,6 +195,8 @@ export function streamForcedTuple(lowerer, info, name) {
         resume: [],
         open: [F64],
         ready: [],
+        // readline.emitKeypressEvents' (str, key), as checked-dynamic values
+        keypress: [DYN, DYN],
     };
     const writable = {
         open: [F64],
@@ -216,7 +232,7 @@ export function streamForcedTuple(lowerer, info, name) {
 function lowerStreamCallback(lowerer, which, node, thisType, fullTuple) {
     const loc = locOf(node);
     const { shapes, funcType } = lowerer.lambdaSignature(node);
-    if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
+    if (node.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
         lowerer.unsupported("SC1090", node, `async stream '${which}' callbacks`);
     }
     if (funcType.params.length > fullTuple.length) {
@@ -243,10 +259,10 @@ function lowerStreamCallback(lowerer, which, node, thisType, fullTuple) {
         const thisLocal = ts.isArrowFunction(node)
             ? lowerer.declareHiddenLocal("this", thisType)
             : lowerer.declareThis(thisType);
-        const { params, prologue } = lowerer.declareParams(node.parameters, shapes);
+        const { params, prologue } = lowerer.declareParams(node.parameters.nodes, shapes);
         let body;
         if (node.body !== undefined && ts.isBlock(node.body)) {
-            body = lowerer.lowerStmts(node.body.statements);
+            body = lowerer.lowerStmts(node.body.statements.nodes);
         }
         else if (node.body !== undefined) {
             // Bare-expression bodies (`read: () => this.push(null)`): the value
@@ -397,7 +413,7 @@ function followOptionsArg(lowerer, arg) {
         catch {
             return node;
         }
-        const decl = sym ? lowerer.checker.valueDeclarationOf(sym) : undefined;
+        const decl = sym ? sym.valueDeclaration : undefined;
         if (!sym || !decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined)
             return node;
         if ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) === 0)
@@ -480,6 +496,28 @@ function dynOptionsValue(lowerer, arg) {
     const v = lowerer.lowerExpr(followed);
     return v.type.kind === "dyn" ? v : null;
 }
+/** @types/node declares the transform/flush completion callback as
+ * `(error?: Error | null, data?: any) => void`. Outside objectMode Node
+ * accepts only a Buffer, a string or nothing as `data`, so the callback
+ * parameter is typed with that union while the option callback lowers: a
+ * checked-dynamic value passed as `data` converts at the call. Returns the
+ * pinned parameter symbol (the caller unpins it), or null when the
+ * declared type needs no pin. */
+function pinAnyDataCompletion(lowerer, which, fnNode) {
+    const index = which === "transform" ? 2 : which === "flush" ? 0 : -1;
+    const param = index < 0 ? undefined : fnNode.parameters.nodes[index];
+    if (param === undefined || !ts.isIdentifier(param.name) || param.dotDotDotToken)
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(param.name);
+    if (!symbol || lowerer.stageSourceTypes.has(symbol))
+        return null;
+    const declared = lowerer.paramShape(param).type;
+    if (declared.kind !== "func" || declared.rest || declared.params[1]?.kind !== "dyn")
+        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;
+}
 /** 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, 
@@ -510,7 +548,7 @@ fallbackCb) {
     }
     const tuples = cbTuples(lowerer);
     const present = new Map();
-    for (const prop of optsLit?.properties ?? []) {
+    for (const prop of optsLit?.properties?.nodes ?? []) {
         const propName = ts.isSpreadAssignment(prop) ? undefined : prop.name;
         const name = propName && ts.isIdentifier(propName)
             ? propName.text
@@ -545,20 +583,27 @@ fallbackCb) {
                 continue;
             }
             const full = tuples[name].map((t) => (t === "fn" ? null : t));
-            // The completion-callback tail: typed by the checker contextually;
-            // accept the user's declared func type as the tuple's entry so the
-            // prefix check compares like with like.
-            const { funcType } = lowerer.lambdaSignature(fnNode);
-            const tuple = full.map((t, i) => {
-                if (t !== null)
-                    return t;
-                const declared = funcType.params[i];
-                if (declared !== undefined && declared.kind !== "func" && declared.kind !== "dyn") {
-                    lowerer.noLowering(`a '${name}' callback whose parameter ${i} is '${lowerer.fmt(declared)}' where Node passes the completion callback`, fnNode);
-                }
-                return declared ?? funcOf([], VOID);
-            });
-            present.set(name, lowerStreamCallback(lowerer, name, fnNode, thisType, tuple));
+            const pinned = pinAnyDataCompletion(lowerer, name, fnNode);
+            try {
+                // The completion-callback tail: typed by the checker contextually;
+                // accept the user's declared func type as the tuple's entry so the
+                // prefix check compares like with like.
+                const { funcType } = lowerer.lambdaSignature(fnNode);
+                const tuple = full.map((t, i) => {
+                    if (t !== null)
+                        return t;
+                    const declared = funcType.params[i];
+                    if (declared !== undefined && declared.kind !== "func" && declared.kind !== "dyn") {
+                        lowerer.noLowering(`a '${name}' callback whose parameter ${i} is '${lowerer.fmt(declared)}' where Node passes the completion callback`, fnNode);
+                    }
+                    return declared ?? funcOf([], VOID);
+                });
+                present.set(name, lowerStreamCallback(lowerer, name, fnNode, thisType, tuple));
+            }
+            finally {
+                if (pinned)
+                    lowerer.stageSourceTypes.delete(pinned);
+            }
             continue;
         }
         // `{ signal }` shorthand: the binding is the value.
@@ -753,7 +798,7 @@ export function lowerStreamNew(lowerer, expr, info) {
     if (!RUNTIME_STREAM_CLASSES.has(cls))
         lowerer.unsupported("SC1090", expr, `constructing ${cls}`);
     const thisType = { kind: "object", className: cls };
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.length > 1) {
         lowerer.noLowering(`new ${info.def.name.slice(1)} with ${args.length} arguments`, expr, "the supported form takes one options object");
     }
@@ -810,6 +855,15 @@ export function lowerStreamNew(lowerer, expr, info) {
         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). */
+function widensInto(lowerer, passed, declared, loc) {
+    if (declared.kind !== "union")
+        return false;
+    const probe = { kind: "varRef", localId: "%probe", type: passed, loc };
+    return typeEquals(lowerer.coerceToExpected(probe, declared).type, declared);
+}
 /* ── user subclasses (`extends Readable`, the underscore-override form) ── */
 /** The wrapper closure binding one overridden underscore method as the
  * runtime's option callback: a lifted (this, ...prefix) function whose
@@ -860,7 +914,14 @@ function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, bl
             }
         }
         else if (!typeEquals(got.type, want)) {
-            lowerer.noLowering(`a '${methodName}' method whose parameter ${i} is '${lowerer.fmt(got.type)}' where Node passes '${lowerer.fmt(want)}'`, blame, "annotate the parameter with the Node signature's type (chunks are Buffers here)");
+            // A declared supertype of what Node passes (`chunk: Buffer | string`)
+            // is sound: the wrapper takes Node's value and widens it into the
+            // declared parameter.
+            if (widensInto(lowerer, want, got.type, loc)) {
+                paramTypes.push(want);
+                continue;
+            }
+            lowerer.noLowering(`a '${methodName}' method whose parameter ${i} is '${lowerer.fmt(got.type)}' where Node passes '${lowerer.fmt(want)}'`, blame, "annotate the parameter with the Node signature's type or a supertype of it (chunks are Buffers here)");
         }
         paramTypes.push(got.type);
     }
@@ -875,7 +936,9 @@ function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, bl
         for (let i = 0; i < paramTypes.length; i++) {
             const local = lowerer.declareHiddenLocal(`a${i}`, paramTypes[i]);
             params.push({ localId: local.id, name: local.name, type: paramTypes[i] });
-            argRefs.push({ kind: "varRef", localId: local.id, type: paramTypes[i], loc });
+            const arg = { kind: "varRef", localId: local.id, type: paramTypes[i], loc };
+            const declaredType = declared[i].type;
+            argRefs.push(typeEquals(arg.type, declaredType) ? arg : lowerer.coerceToExpected(arg, declaredType));
         }
         const thisRef = { kind: "varRef", localId: thisLocal.id, type: thisType, loc };
         let call;
@@ -1159,14 +1222,14 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     // exists; valid shapes keep the fence — the web bridge has no lowering.
     if (member === "toWeb" &&
         cls === "%Readable" &&
-        call.arguments.length === 2 &&
-        isJsSourceFile(call.getSourceFile()) &&
-        ts.isObjectLiteralExpression(call.arguments[1])) {
-        for (const p of call.arguments[1].properties) {
+        call.arguments.nodes.length === 2 &&
+        isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+        ts.isObjectLiteralExpression(call.arguments.nodes[1])) {
+        for (const p of call.arguments.nodes[1].properties.nodes) {
             if (ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "type") {
                 const t = lowerer.typeOf(p.initializer);
                 if (t.isStringLiteralType() && t.value !== "bytes") {
-                    lowerer.lowerExpr(call.arguments[0]); // evaluation order (the stream argument)
+                    lowerer.lowerExpr(call.arguments.nodes[0]); // evaluation order (the stream argument)
                     return nodeThrowExpr(1, "ERR_INVALID_ARG_VALUE", `The property 'options.type' must be one of: 'bytes', undefined. Received '${t.value}'`, lowerer.mapTypeOf(lowerer.typeOf(call)) ?? DYN, loc);
                 }
             }
@@ -1178,12 +1241,12 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     if (cls !== "%Readable") {
         lowerer.noLowering(`${cls.slice(1)}.from`, call, "Readable.from is the lowered form");
     }
-    const args = call.arguments;
+    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" };
-    const js = isJsSourceFile(call.getSourceFile());
+    const js = isJsSourceFile(ts.getSourceFileOfNode(call));
     const srcNode = args[0];
     const optsNode = args[1];
     const srcT = srcNode ? lowerer.mapTypeOf(lowerer.typeOf(srcNode)) : null;
@@ -1191,21 +1254,66 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     const single = typedElem(srcT);
     const elem = srcT?.kind === "array" ? typedElem(srcT.elem) : null;
     const opts = optsNode ? fromOptions(lowerer, optsNode) : { flags: 0, hwm: null };
-    if (srcNode && srcT?.kind === "generator" && opts && fromGenChunk(lowerer, srcT.yieldT)) {
+    // 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.
+    const genMethod = srcT?.kind === "object" ? classGeneratorMethodOf(lowerer, srcT) : null;
+    const genT = srcT?.kind === "generator" ? srcT : (genMethod?.gen ?? null);
+    if (srcNode && genT && opts && fromGenChunk(lowerer, genT.yieldT)) {
         // A compiled generator: the runtime pulls it through interned helpers.
-        const gen = lowerer.lowerExpr(srcNode);
-        const helpers = fromGenHelpers(lowerer, srcT, loc);
+        const recv = lowerer.lowerExpr(srcNode);
+        const gen = genMethod && srcT?.kind === "object"
+            ? accessorCall(lowerer, srcT.className, genMethod.method, recv, [], genT, loc)
+            : recv;
+        const helpers = fromGenHelpers(lowerer, genT, loc);
         if (helpers) {
             const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
             return {
                 kind: "libCall",
-                fn: srcT.async ? "readable.fromAsyncGen" : "readable.fromGen",
+                fn: genT.async ? "readable.fromAsyncGen" : "readable.fromGen",
                 args: [gen, ...helpers, numLit(opts.flags, loc), hwm],
                 type,
                 loc,
             };
         }
     }
+    // from.js prefers Symbol.asyncIterator: a class declaring one takes the
+    // async route.
+    const asyncOpen = srcT?.kind === "object" &&
+        lowerer.classes.has(srcT.className) &&
+        lowerer.findMethodOn(lowerer.classes.get(srcT.className), "sym:asyncIterator") !== null;
+    const cit = srcT?.kind === "object" && !asyncOpen ? classIteratorOf(lowerer, srcT) : null;
+    if (srcNode && cit && opts && fromGenChunk(lowerer, cit.valueT)) {
+        // A class iterable: from.js takes the iterator when the stream is
+        // built (the typed [Symbol.iterator]() call here), and the runtime
+        // pulls it through a checked-dynamic { next } object. Class iterators
+        // declare no return() or throw(), so destroy calls neither.
+        const recv = lowerer.lowerExpr(srcNode);
+        const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
+        return {
+            kind: "libCall",
+            fn: "readable.fromIter",
+            args: [
+                classIteratorObject(lowerer, cit, classIteratorOpenCall(lowerer, cit, recv, loc), loc),
+                numLit(opts.flags, loc),
+                hwm,
+            ],
+            type,
+            loc,
+        };
+    }
+    const acit = srcT?.kind === "object" && asyncOpen ? classAsyncIteratorOf(lowerer, srcT) : null;
+    if (srcNode && acit && opts && fromGenChunk(lowerer, acit.valueT)) {
+        const recv = lowerer.lowerExpr(srcNode);
+        const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
+        return {
+            kind: "libCall",
+            fn: "readable.fromAsyncIter",
+            args: [classAsyncIteratorObject(lowerer, acit, recv, loc), numLit(opts.flags, loc), hwm],
+            type,
+            loc,
+        };
+    }
     if (srcNode && (single || elem) && opts) {
         const v = lowerer.lowerExpr(srcNode);
         const hwm = opts.hwm ? lowerer.lowerExprExpecting(opts.hwm, F64) : numLit(0, loc);
@@ -1222,6 +1330,7 @@ export function lowerStreamStaticCall(lowerer, call, access) {
         };
     }
     const anySrc = srcT?.kind === "dyn" ||
+        (srcT?.kind === "set" && typedElem(srcT.elem) !== null) ||
         (srcNode !== undefined &&
             srcT === null &&
             (lowerer.typeOf(srcNode).flags & ts.TypeFlags.Any) !== 0);
@@ -1235,7 +1344,7 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     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, "string[] / Buffer[] arrays (and a single string or Buffer) are the supported sources — generators and async iterables have no lowering yet");
+    lowerer.noLowering(`Readable.from over a '${srcT ? lowerer.fmt(srcT) : "?"}' source`, srcNode ?? call, "the supported sources are a string or Buffer, and arrays, Sets, generators and class iterables of strings or Buffers");
 }
 /** Whether a generator's yields are stream chunks: strings, Buffers, a
  * union of them (null included: the runtime destroys the stream with
@@ -1363,6 +1472,210 @@ function fromGenHelpers(lowerer, gen, loc) {
         define("throw", [g, e], DYN, viaRecord("throw"), [r]),
     ];
 }
+/** `{ next() { const r = it.next(); return { value: r.value, done: r.done }; } }`
+ * over a class iterator `it`, as a checked-dynamic object: an interned
+ * lifted function per iterator class takes the iterator and answers the
+ * object, whose `next` closure captures it. */
+function classIteratorObject(lowerer, cit, iter, loc) {
+    const key = `streamFromIter:${cit.iterT.className}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        name = `%stream.fromIter.${lowerer.valueHelpers.size}`;
+        lowerer.valueHelpers.set(key, name);
+        const nextName = `${name}.next`;
+        const nextT = funcOf([], DYN);
+        const it = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true };
+        const r = { id: "res.0", name: "res", type: cit.resultT, mutable: false };
+        const field = (f, t) => ({
+            kind: "recordGet",
+            obj: varRef(r.id, cit.resultT, loc),
+            shapeId: cit.resultT.shapeId,
+            field: f,
+            type: t,
+            loc,
+        });
+        const str = (value) => ({ kind: "strLit", value, type: STRING, loc });
+        lowerer.liftedFns.push({
+            name: nextName,
+            params: [],
+            returnType: DYN,
+            captures: [{ localId: it.id, name: it.name, type: it.type }],
+            locals: [it, r],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: r.id,
+                    init: classIteratorNextCall(lowerer, cit, varRef(it.id, cit.iterT, loc), loc),
+                    loc,
+                },
+                {
+                    kind: "return",
+                    value: {
+                        kind: "dynObjLit",
+                        fields: [
+                            {
+                                key: str("value"),
+                                value: lowerer.coerceToExpected(field("value", cit.valueT), DYN),
+                            },
+                            {
+                                key: str("done"),
+                                value: {
+                                    kind: "dynFrom",
+                                    value: cit.hasDone ? field("done", BOOL) : boolLit(false, loc),
+                                    type: DYN,
+                                    loc,
+                                },
+                            },
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: it.id, name: it.name, type: it.type }],
+            returnType: DYN,
+            locals: [it],
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "dynObjLit",
+                        fields: [
+                            {
+                                key: str("next"),
+                                value: {
+                                    kind: "dynFrom",
+                                    value: { kind: "closure", fnName: nextName, captures: [it.id], type: nextT, loc },
+                                    type: DYN,
+                                    loc,
+                                },
+                            },
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [iter], type: DYN, loc };
+}
+/** A class's zero-parameter `[Symbol.asyncIterator]()` (checked first, as
+ * from.js does) or `[Symbol.iterator]()` method that returns a generator,
+ * with its method slot. */
+function classGeneratorMethodOf(lowerer, t) {
+    const info = lowerer.classes.get(t.className);
+    if (!info)
+        return null;
+    for (const method of ["sym:asyncIterator", "sym:iterator"]) {
+        const m = lowerer.findMethodOn(info, method);
+        if (!m)
+            continue;
+        const ret = m.sig.ret;
+        if (m.sig.abstract === true || m.sig.params.length !== 0 || ret.kind !== "generator")
+            return null;
+        return { method, gen: ret };
+    }
+    return null;
+}
+function classAsyncIteratorOf(lowerer, t) {
+    const info = lowerer.classes.get(t.className);
+    const open = info ? lowerer.findMethodOn(info, "sym:asyncIterator") : null;
+    if (!open || open.sig.abstract === true || open.sig.params.length !== 0)
+        return null;
+    const iterT = open.sig.ret;
+    if (iterT.kind !== "object")
+        return null;
+    const itInfo = lowerer.classes.get(iterT.className);
+    if (!itInfo || lowerer.findMethodOn(itInfo, "throw"))
+        return null;
+    const record = (name) => {
+        const m = lowerer.findMethodOn(itInfo, name);
+        if (!m || m.sig.abstract === true || m.sig.params.length !== 0)
+            return null;
+        const ret = m.sig.ret;
+        return ret.kind === "promise" && ret.inner.kind === "record" ? ret.inner : null;
+    };
+    const resultT = record("next");
+    if (!resultT)
+        return null;
+    const shape = lowerer.shapes.get(resultT.shapeId);
+    const value = shape?.fields.find((f) => f.name === "value");
+    const done = shape?.fields.find((f) => f.name === "done");
+    if (!value || (done && done.type.kind !== "bool"))
+        return null;
+    const hasReturn = lowerer.findMethodOn(itInfo, "return") !== null;
+    if (hasReturn && !record("return"))
+        return null;
+    return { className: t.className, iterT, resultT, valueT: value.type, hasReturn };
+}
+/** The checked-dynamic iterator object over an async class iterable:
+ * `recv[Symbol.asyncIterator]()` runs when the stream is built, and the
+ * object's `next` (and `return`, when the class declares one) answer the
+ * iterator's own promises boxed. */
+function classAsyncIteratorObject(lowerer, cit, recv, loc) {
+    const key = `streamFromAsyncIter:${cit.className}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (!name) {
+        name = `%stream.fromAsyncIter.${lowerer.valueHelpers.size}`;
+        lowerer.valueHelpers.set(key, name);
+        const it = { id: "it.0", name: "it", type: cit.iterT, mutable: false, boxed: true };
+        const src = {
+            id: "src.0",
+            name: "src",
+            type: { kind: "object", className: cit.className },
+            mutable: false,
+        };
+        const str = (value) => ({ kind: "strLit", value, type: STRING, loc });
+        const method = (m) => {
+            const fnName = `${name}.${m}`;
+            const call = accessorCall(lowerer, cit.iterT.className, m, varRef(it.id, cit.iterT, loc), [], { kind: "promise", inner: cit.resultT }, loc);
+            lowerer.liftedFns.push({
+                name: fnName,
+                params: [],
+                returnType: DYN,
+                captures: [{ localId: it.id, name: it.name, type: it.type }],
+                locals: [it],
+                body: [{ kind: "return", value: { kind: "dynFrom", value: call, type: DYN, loc }, loc }],
+                loc,
+            });
+            return {
+                key: str(m),
+                value: {
+                    kind: "dynFrom",
+                    value: { kind: "closure", fnName, captures: [it.id], type: funcOf([], DYN), loc },
+                    type: DYN,
+                    loc,
+                },
+            };
+        };
+        const fields = [method("next"), ...(cit.hasReturn ? [method("return")] : [])];
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: src.id, name: src.name, type: src.type }],
+            returnType: DYN,
+            locals: [src, it],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: it.id,
+                    init: accessorCall(lowerer, cit.className, "sym:asyncIterator", varRef(src.id, src.type, loc), [], cit.iterT, loc),
+                    loc,
+                },
+                { kind: "return", value: { kind: "dynObjLit", fields, type: DYN, loc }, loc },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [recv], type: DYN, loc };
+}
 /** Readable.from's typed options: an object literal of `objectMode`
  * (a boolean literal) and `highWaterMark` (a number), as SCR_FROM_* flag
  * bits and the hwm expression; null for any other shape. */
@@ -1371,7 +1684,7 @@ function fromOptions(lowerer, node) {
         return null;
     let flags = 0;
     let hwm = null;
-    for (const prop of node.properties) {
+    for (const prop of node.properties.nodes) {
         if (!ts.isPropertyAssignment(prop) ||
             !(ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))) {
             return null;
@@ -1429,7 +1742,30 @@ const PIPELINE_STAGE_EXPECTED = "of type function or an instance of Blob, Readab
  * { readable, writable } pairs — those shapes fence instead of throwing
  * a ladder Node never throws. */
 function lowerStreamArg(lowerer, node, what) {
-    const v = lowerer.lowerExpr(node);
+    const lowered = lowerer.lowerExpr(node);
+    // A Hash or Hmac stage is its Transform; pipeline and compose stages
+    // keep the value alive until the stream settles.
+    const v = isHashValueType(lowered.type)
+        ? hashStreamOf(lowered, what === "pipeline" || what === "compose")
+        : lowered;
+    // A checked-dynamic pipeline stage (an untyped source or destination):
+    // a boxed native stream unwraps at run time; other values (iterables,
+    // functions) throw the not-supported Error there.
+    if (v.type.kind === "dyn" && what === "pipeline") {
+        noteUntypedStreamFlow(lowerer, null);
+        return {
+            kind: "libCall",
+            fn: "stream.unboxDyn",
+            args: [
+                v,
+                strLit(lowerer.dynNodeStreams
+                    ? "pipeline stages other than native streams (JavaScript stream objects, iterables, generators, plain functions, and { readable, writable } pairs) are not supported yet"
+                    : "pipeline stages other than native streams (iterables, generators, plain functions, and { readable, writable } pairs) are not supported yet", locOf(node)),
+            ],
+            type: { kind: "object", className: "%Duplex" },
+            loc: locOf(node),
+        };
+    }
     const info = v.type.kind === "object" ? lowerer.classes.get(v.type.className) : undefined;
     if (!streamSidesOf(lowerer, info)) {
         // A provably-non-stream value in a JS source (the invalid-input
@@ -1448,7 +1784,7 @@ function lowerStreamArg(lowerer, node, what) {
                 loc: locOf(node),
             });
         };
-        if (isJsSourceFile(node.getSourceFile()) && lowerer.dynConvertible(v.type)) {
+        if (isJsSourceFile(ts.getSourceFileOfNode(node)) && lowerer.dynConvertible(v.type)) {
             if (what === "pipeline") {
                 // Strings and arrays are iterables — VALID pipeline stages in
                 // Node — and a record carrying a readable/writable member may be
@@ -1463,7 +1799,7 @@ function lowerStreamArg(lowerer, node, what) {
                     argTypeThrow("body", PIPELINE_STAGE_EXPECTED);
                 }
             }
-            else if ((ts.isObjectLiteralExpression(node) && node.properties.length === 0) ||
+            else if ((ts.isObjectLiteralExpression(node) && node.properties.nodes.length === 0) ||
                 v.type.kind === "record" ||
                 v.type.kind === "string" ||
                 v.type.kind === "f64" ||
@@ -1569,7 +1905,7 @@ function eosOptions(lowerer, node, promiseForm) {
             return false;
         lowerer.noLowering(`the finished option '${key}' with a non-literal value`, p.initializer, "pass true or false");
     };
-    for (const p of node.properties) {
+    for (const p of node.properties.nodes) {
         const key = (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) && ts.isIdentifier(p.name)
             ? p.name.text
             : null;
@@ -1603,7 +1939,7 @@ function eosOptions(lowerer, node, promiseForm) {
  * any expression, end as a boolean literal. */
 function pipelineOptions(lowerer, node) {
     const out = { end: true, signal: null };
-    for (const p of node.properties) {
+    for (const p of node.properties.nodes) {
         const key = (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) && ts.isIdentifier(p.name)
             ? p.name.text
             : null;
@@ -1632,7 +1968,7 @@ function pipelineOptions(lowerer, node) {
  * does not own — the caller's module-qualified fence speaks. */
 export function lowerStreamModuleCall(lowerer, call, bi, loc) {
     if (bi.module === "stream/promises") {
-        const args = call.arguments;
+        const args = call.arguments.nodes;
         // finished(stream) → a pending void promise the terminal watcher
         // settles (rejected with the stream's error, or
         // ERR_STREAM_PREMATURE_CLOSE — the callback form's status, boxed
@@ -1733,7 +2069,7 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
         return null;
     }
     if (bi.module === "stream/consumers") {
-        const args = call.arguments;
+        const args = call.arguments.nodes;
         // text/json/buffer/arrayBuffer(stream) → a pending promise the
         // accumulate-and-settle machinery resolves at the terminal point (the
         // utf8 decode / the parsed JSON dyn tree / the concatenated bytes / an
@@ -1774,7 +2110,7 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
     }
     if (bi.module !== "stream")
         return null;
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     if (bi.member === "getDefaultHighWaterMark") {
         // Node 24: 65536 bytes / 16 objects — compile-time literals only.
         // The byte default is platform-split at Node's source
@@ -1946,7 +2282,7 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
     for (let i = first; i < end; i++) {
         const fn = stageArgs[i];
         const isLast = destFn && i === end - 1;
-        const isAsync = (fn.modifiers ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+        const isAsync = (fn.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
         const isGen = ts.isFunctionExpression(fn) && fn.asteriskToken !== undefined;
         if (isLast && isGen) {
             // pipeline() pumps it into an object-mode PassThrough, whose
@@ -1961,14 +2297,14 @@ function lowerPipelineStages(lowerer, stageArgs, loc) {
                     : "pipeline stages that are not async generator functions", fn, "write the stage as async function* (source) { for await (const chunk of source) ... }");
         }
         const optionsAt = srcT === null ? 0 : 1;
-        if (fn.parameters.length > optionsAt + 1) {
-            lowerer.noLowering("pipeline stages with parameters after the options argument", fn.parameters[optionsAt + 1], "a stage takes the source and { signal }");
+        if (fn.parameters.nodes.length > optionsAt + 1) {
+            lowerer.noLowering("pipeline stages with parameters after the options argument", fn.parameters.nodes[optionsAt + 1], "a stage takes the source and { signal }");
         }
         const lowered = lowerStageFunction(lowerer, fn, srcT);
         const params = lowered.closure.type.kind === "func" ? lowered.closure.type.params : [];
         if (params.length > optionsAt) {
             if (params[optionsAt].kind !== "dyn") {
-                lowerer.noLowering("a pipeline stage's options argument with this type", fn.parameters[optionsAt], "type it as { signal: AbortSignal }");
+                lowerer.noLowering("a pipeline stage's options argument with this type", fn.parameters.nodes[optionsAt], "type it as { signal: AbortSignal }");
             }
             mask |= 1 << (i - first);
         }
@@ -2151,7 +2487,7 @@ function pipelineAbortHelper(lowerer, ac, loc) {
  * `for await` loops. Answers the closure and what it returns: an async
  * generator, or a promise for a destination async function. */
 function lowerStageFunction(lowerer, fn, srcT) {
-    const param = srcT === null ? undefined : fn.parameters[0];
+    const param = srcT === null ? undefined : fn.parameters.nodes[0];
     const symbol = param && ts.isIdentifier(param.name)
         ? lowerer.checker.getSymbolAtLocation(param.name)
         : undefined;
@@ -2196,7 +2532,7 @@ function lowerStageFunction(lowerer, fn, srcT) {
  * 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;
+    const args = call.arguments.nodes;
     const duplex = { kind: "object", className: "%Duplex" };
     if (args.some((a) => ts.isSpreadElement(a))) {
         lowerer.noLowering("compose with spread arguments", call, "pass the streams directly");
@@ -2260,14 +2596,14 @@ 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.length > maxParams) {
-        optionsParam(node.parameters[maxParams]);
+        node.parameters.nodes.length > maxParams) {
+        optionsParam(node.parameters.nodes[maxParams]);
     }
     const v = lowerer.lowerExpr(node);
     if (v.type.kind === "dyn")
         return v;
     if (v.type.kind !== "func" &&
-        isJsSourceFile(node.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(node)) &&
         lowerer.dynConvertible(v.type)) {
         // JavaScript passes any value; Node's validateFunction throws.
         return { kind: "dynFrom", value: v, type: DYN, loc };
@@ -2317,7 +2653,7 @@ function lowerOperatorValue(lowerer, node, what, loc, literalObject) {
 }
 function lowerStreamOperator(lowerer, call, access, member) {
     const loc = locOf(call);
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     const recv = lowerer.lowerExpr(access.expression);
     const readable = { kind: "object", className: "%Readable" };
     const opts = (i) => lowerOperatorValue(lowerer, args[i], `${member} options`, loc, true);
@@ -2420,6 +2756,226 @@ function checkUtf8Encoding(lowerer, member, arg) {
 }
 /** `recv.<member>(...)` over a stream-rooted receiver. Returns null only
  * for members this spoke does not own. */
+/** pipe()'s `{ end }` option: true when absent. */
+function pipeEndOption(lowerer, options, loc) {
+    let end = boolLit(true, loc);
+    if (options === undefined)
+        return end;
+    if (!ts.isObjectLiteralExpression(options)) {
+        lowerer.noLowering("pipe with a non-literal options argument", options, "{ end: <bool> } inline is the supported form");
+    }
+    for (const prop of options.properties.nodes) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name) || prop.name.text !== "end") {
+            lowerer.noLowering("a pipe option other than 'end'", prop);
+        }
+        end = lowerer.lowerExprExpecting(prop.initializer, BOOL);
+    }
+    return end;
+}
+/** `readable.pipe(process.stdout)`: the process stream joins the pipe as
+ * an fd-backed Writable (stream.stdioWritable), and — like Node, which
+ * never ends process.stdout or process.stderr from a pipe — the source's
+ * end does not end it. pipe() answers the process stream itself. */
+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 source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type);
+    const stdio = lowerer.declareHiddenLocal("%pipeStdio", target.type);
+    const options = call.arguments.nodes[1];
+    const stmts = [
+        { kind: "varDecl", localId: source.id, init: receiverValue, loc },
+        { kind: "varDecl", localId: stdio.id, init: target, loc },
+    ];
+    // The options literal still evaluates; its end flag has no effect here.
+    if (options !== undefined) {
+        stmts.push({ kind: "exprStmt", expr: pipeEndOption(lowerer, options, loc), loc });
+    }
+    const receiver = { kind: "varRef", localId: source.id, type: receiverValue.type, loc };
+    const writable = { kind: "object", className: "%Writable" };
+    stmts.push({
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "readable.pipe",
+            args: [
+                receiver,
+                {
+                    kind: "libCall",
+                    fn: "stream.stdioWritable",
+                    args: [{ kind: "varRef", localId: stdio.id, type: target.type, loc }],
+                    type: writable,
+                    loc,
+                },
+                boolLit(false, loc),
+            ],
+            type: writable,
+            loc,
+        },
+        loc,
+    });
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: { kind: "varRef", localId: stdio.id, type: target.type, loc },
+        type: target.type,
+        loc,
+    };
+}
+/** `readable.unpipe(untyped)`: a native destination (boxed) unpipes as a
+ * typed one does; any other value unpipes the JavaScript destination a
+ * pipe into it registered (scr_stream_dyn.c), or does nothing when there
+ * is none, as Node's unpipe does for a destination it is not piped into.
+ * The call answers the source. */
+function unpipeDyn(lowerer, receiver, dst, loc) {
+    noteUntypedStreamFlow(lowerer, null);
+    const source = lowerer.declareHiddenLocal("%unpipeSource", receiver.type);
+    const destination = lowerer.declareHiddenLocal("%unpipeDestination", dst.type);
+    const sourceRef = varRef(source.id, receiver.type, loc);
+    const destinationRef = varRef(destination.id, dst.type, loc);
+    const stmts = [
+        { kind: "varDecl", localId: source.id, init: receiver, loc },
+        { kind: "varDecl", localId: destination.id, init: dst, loc },
+    ];
+    const unpipeNative = (native) => ({
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "readable.unpipe",
+            args: [sourceRef, native],
+            type: receiver.type,
+            loc,
+        },
+        loc,
+    });
+    if (lowerer.dynNodeStreams) {
+        stmts.push(dynNativeBranch(lowerer, destinationRef, "w", unpipeNative, {
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "stream.unpipeDyn",
+                args: [sourceRef, destinationRef],
+                type: VOID,
+                loc,
+            },
+            loc,
+        }));
+    }
+    else {
+        stmts.push(unpipeNative({
+            kind: "libCall",
+            fn: "stream.unboxDyn",
+            args: [
+                destinationRef,
+                strLit("unpipe destinations other than native streams are not supported yet", loc),
+            ],
+            type: { kind: "object", className: "%Duplex" },
+            loc,
+        }));
+    }
+    return { kind: "seqExpr", stmts, result: sourceRef, type: receiver.type, loc };
+}
+/** The pipe() libCall for a destination of type `dst`. Under the general
+ * stream representation a Writable slot can hold the converted
+ * process.stdout / process.stderr, which a pipe never ends (as in Node), so
+ * the pipe takes readable.pipeGeneral, which checks for them. */
+function generalPipe(lowerer, dst) {
+    return lowerer.generalNodeStreams && dst.kind === "object" && dst.className === "%Writable"
+        ? "readable.pipeGeneral"
+        : "readable.pipe";
+}
+/** `readable.pipe(untyped)`: a checked-dynamic destination unwraps a boxed
+ * native stream at run time (stream.unboxDyn; other values throw the
+ * not-supported Error), and pipe() answers the destination value itself. */
+function pipeIntoDyn(lowerer, call, access, target) {
+    const loc = locOf(call);
+    noteUntypedStreamFlow(lowerer, null);
+    const receiverValue = lowerer.lowerExpr(access.expression);
+    const source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type);
+    const destination = lowerer.declareHiddenLocal("%pipeDestination", target.type);
+    const stmts = [
+        { kind: "varDecl", localId: source.id, init: receiverValue, loc },
+        { kind: "varDecl", localId: destination.id, init: target, loc },
+    ];
+    const end = pipeEndOption(lowerer, call.arguments.nodes[1], loc);
+    const duplex = { kind: "object", className: "%Duplex" };
+    // Checked-dynamic stream slots (dyn-streams.ts): a JavaScript stream
+    // object is a destination too, piped with Node's listener protocol.
+    if (lowerer.dynNodeStreams) {
+        const sourceRef = { kind: "varRef", localId: source.id, type: receiverValue.type, loc };
+        const destinationRef = {
+            kind: "varRef",
+            localId: destination.id,
+            type: target.type,
+            loc,
+        };
+        const ending = lowerer.declareHiddenLocal("%pipeEnd", BOOL);
+        stmts.push({ kind: "varDecl", localId: ending.id, init: end, loc });
+        const endRef = { kind: "varRef", localId: ending.id, type: BOOL, loc };
+        stmts.push(dynNativeBranch(lowerer, destinationRef, "w", (native) => ({
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                // Checked-dynamic slots come with the general representation,
+                // where a boxed native destination can be the converted
+                // process.stdout (generalPipe).
+                fn: "readable.pipeGeneral",
+                args: [sourceRef, native, endRef],
+                type: native.type,
+                loc,
+            },
+            loc,
+        }), {
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "stream.pipeDyn",
+                args: [sourceRef, lowerer.coerceToExpected(sourceRef, DYN), destinationRef, endRef],
+                type: VOID,
+                loc,
+            },
+            loc,
+        }));
+        return {
+            kind: "seqExpr",
+            stmts,
+            result: destinationRef,
+            type: target.type,
+            loc,
+        };
+    }
+    stmts.push({
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: lowerer.generalNodeStreams ? "readable.pipeGeneral" : "readable.pipe",
+            args: [
+                { kind: "varRef", localId: source.id, type: receiverValue.type, loc },
+                {
+                    kind: "libCall",
+                    fn: "stream.unboxDyn",
+                    args: [
+                        { kind: "varRef", localId: destination.id, type: target.type, loc },
+                        strLit("pipe destinations other than native streams are not supported yet", loc),
+                    ],
+                    type: duplex,
+                    loc,
+                },
+                end,
+            ],
+            type: duplex,
+            loc,
+        },
+        loc,
+    });
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: { kind: "varRef", localId: destination.id, type: target.type, loc },
+        type: target.type,
+        loc,
+    };
+}
 export function lowerStreamMethodCall(lowerer, call, access, info) {
     const member = access.name.text;
     if (STREAM_OPERATORS.has(member)) {
@@ -2433,7 +2989,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
     if (!sides)
         return null;
     const loc = locOf(call);
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     const readableSide = sides === "r" || sides === "rw";
     const writableSide = sides === "w" || sides === "rw";
     const cls = info.def.name.slice(1);
@@ -2604,30 +3160,57 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         if (args.length === 0 || args.length > 2) {
             lowerer.noLowering(`pipe with ${args.length} arguments`, call, "the supported forms are (destination) and (destination, { end })");
         }
-        const dst = lowerer.lowerExpr(args[0]);
+        // A Hash or Hmac destination pipes into its Transform, and pipe()
+        // answers the Hash itself (the receiver evaluates first, as in JS).
+        if (isHashValueType(lowerer.mapTypeOf(lowerer.typeOf(args[0])))) {
+            const receiverValue = lowerer.lowerExpr(access.expression);
+            const source = lowerer.declareHiddenLocal("%pipeSource", receiverValue.type);
+            const hashValue = lowerer.lowerExpr(args[0]);
+            const hash = lowerer.declareHiddenLocal("%pipeHash", hashValue.type);
+            const end = pipeEndOption(lowerer, args[1], loc);
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "varDecl", localId: source.id, init: receiverValue, loc },
+                    { kind: "varDecl", localId: hash.id, init: hashValue, loc },
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "libCall",
+                            fn: "readable.pipe",
+                            args: [
+                                { kind: "varRef", localId: source.id, type: receiverValue.type, loc },
+                                hashStreamOf({ kind: "varRef", localId: hash.id, type: hashValue.type, loc }, true),
+                                end,
+                            ],
+                            type: { kind: "object", className: "%Transform" },
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                result: { kind: "varRef", localId: hash.id, type: hashValue.type, loc },
+                type: hashValue.type,
+                loc,
+            };
+        }
+        const target = lowerer.lowerExpr(args[0]);
+        if (target.type.kind === "procStream")
+            return pipeIntoStdio(lowerer, call, access, target);
+        if (target.type.kind === "dyn")
+            return pipeIntoDyn(lowerer, call, access, target);
+        const dst = target;
         const dstInfo = dst.type.kind === "object" ? lowerer.classes.get(dst.type.className) : undefined;
         const dstSides = streamSidesOf(lowerer, dstInfo);
         if (dstSides !== "w" && dstSides !== "rw") {
-            lowerer.noLowering(`pipe into a '${lowerer.fmt(dst.type)}'`, args[0], "the destination must be a stream Writable/Duplex (process streams and sockets are not pipe destinations yet)");
-        }
-        let end = boolLit(true, loc);
-        if (args[1] !== undefined) {
-            if (!ts.isObjectLiteralExpression(args[1])) {
-                lowerer.noLowering("pipe with a non-literal options argument", args[1], "{ end: <bool> } inline is the supported form");
-            }
-            for (const prop of args[1].properties) {
-                if (!ts.isPropertyAssignment(prop) ||
-                    !ts.isIdentifier(prop.name) ||
-                    prop.name.text !== "end") {
-                    lowerer.noLowering("a pipe option other than 'end'", prop);
-                }
-                end = lowerer.lowerExprExpecting(prop.initializer, BOOL);
-            }
+            requestGeneralStreamSurface(lowerer, args[0]);
+            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);
         return {
             kind: "libCall",
-            fn: "readable.pipe",
+            fn: generalPipe(lowerer, dst.type),
             args: [receiver, dst, end],
             type: dst.type,
             loc,
@@ -2640,6 +3223,8 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         const receiver = lowerer.lowerExpr(access.expression);
         if (args[0] !== undefined) {
             const dst = lowerer.lowerExpr(args[0]);
+            if (dst.type.kind === "dyn")
+                return unpipeDyn(lowerer, receiver, dst, loc);
             const dstInfo = dst.type.kind === "object" ? lowerer.classes.get(dst.type.className) : undefined;
             const dstSides = streamSidesOf(lowerer, dstInfo);
             if (dstSides !== "w" && dstSides !== "rw") {
@@ -2653,6 +3238,44 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 loc,
             };
         }
+        // Checked-dynamic slots: unpipe() also unpipes the JavaScript
+        // destinations stream.pipeDyn registered (stream.unpipeDyn with an
+        // undefined destination), as Node's unpipe() empties every pipe.
+        if (lowerer.dynNodeStreams) {
+            const source = lowerer.declareHiddenLocal("%unpipeSource", receiver.type);
+            const sourceRef = varRef(source.id, receiver.type, loc);
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "varDecl", localId: source.id, init: receiver, loc },
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "libCall",
+                            fn: "readable.unpipe",
+                            args: [sourceRef],
+                            type: receiver.type,
+                            loc,
+                        },
+                        loc,
+                    },
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "libCall",
+                            fn: "stream.unpipeDyn",
+                            args: [sourceRef, dynUndefinedExpr(loc)],
+                            type: VOID,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                result: sourceRef,
+                type: receiver.type,
+                loc,
+            };
+        }
         return { kind: "libCall", fn: "readable.unpipe", args: [receiver], type: receiver.type, loc };
     }
     if (member === "destroy") {
@@ -2741,8 +3364,10 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             : lowerer.lowerExprExpecting(args[0], STRING);
         const fn = kind === "bytes" ? "writable.write" : "writable.writeStr";
         if (cbArg !== undefined) {
-            const cb = lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
-            if (cb.type.kind !== "func" || cb.type.params.length > 0) {
+            const cb = callbackDeclaresParameters(cbArg)
+                ? null
+                : lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
+            if (cb === null || cb.type.kind !== "func" || cb.type.params.length > 0) {
                 lowerer.noLowering("write completion callbacks taking the error argument", cbArg, "() => void callbacks are supported (listen for 'error' to observe failures)");
             }
             return { kind: "libCall", fn, args: [receiver, chunk, cb], type: BOOL, loc };
@@ -2802,8 +3427,10 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                     : lowerer.lowerExprExpecting(chunkNode, STRING));
         }
         if (cbArg !== undefined) {
-            const cb = lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
-            if (cb.type.kind !== "func" || cb.type.params.length > 0) {
+            const cb = callbackDeclaresParameters(cbArg)
+                ? null
+                : lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
+            if (cb === null || cb.type.kind !== "func" || cb.type.params.length > 0) {
                 lowerer.noLowering("end callbacks with parameters", cbArg, "() => void callbacks are supported");
             }
             flags |= 4;
@@ -3037,4 +3664,16 @@ export function lowerStreamProperty(lowerer, expr, info) {
     }
     return null;
 }
+/** Whether an inline completion callback declares a parameter. Node calls
+ * write and end callbacks with an error argument (null on success), but the
+ * native callback receives none, so the parameter would read undefined
+ * where Node passes null or the error. A function literal with parameters
+ * would otherwise adapt to the zero-parameter slot silently. */
+function callbackDeclaresParameters(node) {
+    let callback = node;
+    while (ts.isParenthesizedExpression(callback))
+        callback = callback.expression;
+    return ((ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) &&
+        callback.parameters.nodes.length > 0);
+}
 //# sourceMappingURL=lower-stream.js.map