@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -41,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;
@@ -129,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) {
@@ -221,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) {
@@ -248,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
@@ -402,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)
@@ -485,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, 
@@ -515,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
@@ -550,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.
@@ -758,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");
     }
@@ -815,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
@@ -865,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);
     }
@@ -880,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;
@@ -1164,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);
                 }
             }
@@ -1183,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;
@@ -1626,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;
@@ -1690,6 +1748,24 @@ function lowerStreamArg(lowerer, node, what) {
     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
@@ -1708,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
@@ -1723,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" ||
@@ -1829,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;
@@ -1863,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;
@@ -1892,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
@@ -1993,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
@@ -2034,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
@@ -2206,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
@@ -2221,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);
         }
@@ -2411,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;
@@ -2456,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");
@@ -2520,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 };
@@ -2577,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);
@@ -2688,7 +2764,7 @@ function pipeEndOption(lowerer, options, loc) {
     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) {
+    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);
         }
@@ -2696,6 +2772,210 @@ function pipeEndOption(lowerer, options, loc) {
     }
     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)) {
@@ -2709,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);
@@ -2914,17 +3194,23 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 loc,
             };
         }
-        const dst = lowerer.lowerExpr(args[0]);
+        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)");
+            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,
@@ -2937,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") {
@@ -2950,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") {
@@ -3038,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 };
@@ -3099,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;
@@ -3334,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