@scriptc/compiler 0.2.4 → 0.2.5

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

@@ -1,3 +1,4 @@
+import { nodeThrowExpr, boolLit, numLit, strLit } from "../../ir/build.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
@@ -28,14 +29,13 @@ import { InternalCompilerError } from "../../errors.js";
  * compiler-emitted invoke adapters. A callback may declare any PREFIX of
  * its Node signature (the emitter listener rule). */
 import * as ts from "../ts7/adapter.js";
-import { dynFallbackType, nodeThrowExpr } from "./lowerer.js";
+import { dynFallbackType } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { newFnCtx, own } from "./lowerer.js";
-import { appendImplicitUndefinedReturn } from "./lower-calls.js";
+import { appendImplicitUndefinedReturn } from "./function-returns.js";
 import { bufEncoding, knownBufEncoding } from "./containers/bytes.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
-import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, BYTES_U8, canBoxFuncIntoDyn, funcOf, typeEquals, typeKey } from "../../ir/ir.js";
-import { boolLit, numLit, strLit } from "../../ir/build.js";
+import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, BYTES_U8, canBoxFuncIntoDyn, funcOf, typeEquals, typeKey, } from "../../ir/ir.js";
 const BYTES = BYTES_U8;
 /** The stream sides of a receiver class: the nearest stream-class
  * ancestor's, or null off the stream hierarchy. */
@@ -49,8 +49,20 @@ export function streamSidesOf(lowerer, info) {
 /** The instance members the stream spoke owns on stream-rooted
  * receivers (the emitter members ride the base chain as usual). */
 export const STREAM_API_MEMBERS = new Set([
-    "push", "unshift", "read", "pause", "resume", "isPaused", "setEncoding",
-    "pipe", "unpipe", "destroy", "write", "end", "cork", "uncork",
+    "push",
+    "unshift",
+    "read",
+    "pause",
+    "resume",
+    "isPaused",
+    "setEncoding",
+    "pipe",
+    "unpipe",
+    "destroy",
+    "write",
+    "end",
+    "cork",
+    "uncork",
     "setDefaultEncoding",
 ]);
 /** The property names the stream spoke owns (lowerStreamProperty) — a
@@ -58,11 +70,24 @@ export const STREAM_API_MEMBERS = new Set([
  * against the runtime state, so collection fences them (the
  * EMITTER_API_MEMBERS precedent). */
 export const STREAM_PROP_MEMBERS = new Set([
-    "readable", "readableEnded", "readableFlowing", "readableLength",
-    "readableHighWaterMark", "readableObjectMode",
-    "writable", "writableEnded", "writableFinished", "writableNeedDrain",
-    "writableLength", "writableHighWaterMark", "writableCorked",
-    "writableObjectMode", "destroyed", "closed", "errored", "allowHalfOpen",
+    "readable",
+    "readableEnded",
+    "readableFlowing",
+    "readableLength",
+    "readableHighWaterMark",
+    "readableObjectMode",
+    "writable",
+    "writableEnded",
+    "writableFinished",
+    "writableNeedDrain",
+    "writableLength",
+    "writableHighWaterMark",
+    "writableCorked",
+    "writableObjectMode",
+    "destroyed",
+    "closed",
+    "errored",
+    "allowHalfOpen",
 ]);
 /** The underscore methods each runtime base consumes at construction
  * (option-callback name → method name). A stream subclass declaring an
@@ -98,8 +123,17 @@ export function streamCtorShape(cls) {
 /** Names emitted internally by stream runtimes. A computed EventEmitter
  * name must not match one, even through an EventEmitter-typed stream upcast. */
 export const STREAM_FORCED_EVENT_NAMES = new Set([
-    "data", "end", "close", "readable", "pause", "resume",
-    "drain", "prefinish", "finish", "pipe", "unpipe",
+    "data",
+    "end",
+    "close",
+    "readable",
+    "pause",
+    "resume",
+    "drain",
+    "prefinish",
+    "finish",
+    "pipe",
+    "unpipe",
 ]);
 /** The per-base FORCED event tuples (runtime-emitted payloads): consulted
  * by the emitter spoke BEFORE the program-global table, so a stream's
@@ -191,7 +225,13 @@ function lowerStreamCallback(lowerer, which, node, thisType, fullTuple) {
             }
             else {
                 const value = lowerer.lowerExpr(bodyExpr);
-                body = [{ kind: "return", value: lowerer.coerceInto(bodyExpr, value, funcType.ret), loc: locOf(node.body) }];
+                body = [
+                    {
+                        kind: "return",
+                        value: lowerer.coerceInto(bodyExpr, value, funcType.ret),
+                        loc: locOf(node.body),
+                    },
+                ];
             }
         }
         else {
@@ -276,10 +316,10 @@ function propMutatedSymbols(lowerer) {
             continue;
         const walk = (node) => {
             ts.forEachChild(node, walk);
-            if (ts.isBinaryExpression(node)
-                && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment
-                && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
-                && (ts.isPropertyAccessExpression(node.left) || ts.isElementAccessExpression(node.left))) {
+            if (ts.isBinaryExpression(node) &&
+                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment &&
+                (ts.isPropertyAccessExpression(node.left) || ts.isElementAccessExpression(node.left))) {
                 noteBase(node.left);
             }
             else if (ts.isDeleteExpression(node)) {
@@ -635,10 +675,23 @@ function streamCtorArgs(lowerer, cls, arg, thisType, loc, fallbackCb) {
     const shape = streamCtorShape(cls);
     const o = parseStreamOptions(lowerer, cls.slice(1), arg, thisType, shape.accepted, loc, fallbackCb);
     const head = shape.duplexShape
-        ? [o.hwmR, o.hwmW, o.autoDestroy, o.emitClose, o.allowHalfOpen,
-            boolLit(o.readableSide, loc), boolLit(o.writableSide, loc), numLit(o.flags, loc)]
+        ? [
+            o.hwmR,
+            o.hwmW,
+            o.autoDestroy,
+            o.emitClose,
+            o.allowHalfOpen,
+            boolLit(o.readableSide, loc),
+            boolLit(o.writableSide, loc),
+            numLit(o.flags, loc),
+        ]
         : [cls === "%Writable" ? o.hwmW : o.hwmR, o.autoDestroy, o.emitClose, numLit(o.flags, loc)];
-    return { args: [...head, ...o.cbs], encoding: o.encoding, badEncoding: o.badEncoding, pushEncoding: o.pushEncoding };
+    return {
+        args: [...head, ...o.cbs],
+        encoding: o.encoding,
+        badEncoding: o.badEncoding,
+        pushEncoding: o.pushEncoding,
+    };
 }
 /** `new Readable(opts?)` and friends — called from lowerNew once the
  * callee resolved to a builtin stream class. */
@@ -655,7 +708,13 @@ export function lowerStreamNew(lowerer, expr, info) {
     if (args[0] !== undefined) {
         const dynOpts = dynOptionsValue(lowerer, args[0]);
         if (dynOpts !== null) {
-            return { kind: "libCall", fn: `${streamCtorShape(cls).fn}.newDyn`, args: [dynOpts], type: thisType, loc };
+            return {
+                kind: "libCall",
+                fn: `${streamCtorShape(cls).fn}.newDyn`,
+                args: [dynOpts],
+                type: thisType,
+                loc,
+            };
         }
     }
     const fn = `${streamCtorShape(cls).fn}.new`;
@@ -669,13 +728,25 @@ export function lowerStreamNew(lowerer, expr, info) {
     if (parsed.pushEncoding !== null) {
         // { defaultEncoding }: chain the push-side decode default (the
         // setEncoding chaining shape — answers the receiver +1).
-        built = { kind: "libCall", fn: "readable.pushEncoding", args: [built, strLit(parsed.pushEncoding, loc)], type: thisType, loc };
+        built = {
+            kind: "libCall",
+            fn: "readable.pushEncoding",
+            args: [built, strLit(parsed.pushEncoding, loc)],
+            type: thisType,
+            loc,
+        };
     }
     if (parsed.encoding === null)
         return built;
     // { encoding }: chain a setEncoding over the fresh stream (the operand
     // temp releases with the frame; setEncoding answers the receiver +1).
-    return { kind: "libCall", fn: "readable.setEncoding", args: [built, strLit(parsed.encoding, loc)], type: thisType, loc };
+    return {
+        kind: "libCall",
+        fn: "readable.setEncoding",
+        args: [built, strLit(parsed.encoding, loc)],
+        type: thisType,
+        loc,
+    };
 }
 /* ── user subclasses (`extends Readable`, the underscore-override form) ── */
 /** The wrapper closure binding one overridden underscore method as the
@@ -748,7 +819,14 @@ function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, bl
         let call;
         if (lowerer.overrideBelow(info, methodName)) {
             lowerer.noteVirtualEdge(info, methodName);
-            call = { kind: "virtualCall", className: info.def.name, method: methodName, args: [thisRef, ...argRefs], type: ret, loc };
+            call = {
+                kind: "virtualCall",
+                className: info.def.name,
+                method: methodName,
+                args: [thisRef, ...argRefs],
+                type: ret,
+                loc,
+            };
         }
         else {
             lowerer.noteEdge(`%${found.declarer.def.name}.${methodName}`);
@@ -795,7 +873,9 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
     const shape = streamCtorShape(cls);
     const fallback = (name) => {
         const methodName = UNDERSCORE_METHODS.get(name);
-        return methodName ? streamMethodWrapper(lowerer, info, name, methodName, thisType, loc, blame) : null;
+        return methodName
+            ? streamMethodWrapper(lowerer, info, name, methodName, thisType, loc, blame)
+            : null;
     };
     const thisRef = () => ({ kind: "varRef", localId: thisLocal.id, type: thisType, loc });
     if (argNodes[0] !== undefined) {
@@ -813,7 +893,8 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
                     cbs.push(cb);
                 }
             }
-            return [{
+            return [
+                {
                     kind: "exprStmt",
                     expr: {
                         kind: "libCall",
@@ -823,35 +904,58 @@ export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, l
                         loc,
                     },
                     loc,
-                }];
+                },
+            ];
         }
     }
     const parsed = streamCtorArgs(lowerer, cls, argNodes[0], thisType, loc, fallback);
     if (parsed.badEncoding !== null) {
         // super(options) with an unknown literal encoding: the state ctor
         // rejects before any initialization, Node's ladder.
-        return [{
+        return [
+            {
                 kind: "exprStmt",
                 expr: nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", `Unknown encoding: ${parsed.badEncoding}`, VOID, loc),
                 loc,
-            }];
+            },
+        ];
     }
-    const out = [{
+    const out = [
+        {
             kind: "exprStmt",
-            expr: { kind: "libCall", fn: `${shape.fn}.init`, args: [thisRef(), ...parsed.args], type: VOID, loc },
+            expr: {
+                kind: "libCall",
+                fn: `${shape.fn}.init`,
+                args: [thisRef(), ...parsed.args],
+                type: VOID,
+                loc,
+            },
             loc,
-        }];
+        },
+    ];
     if (parsed.pushEncoding !== null) {
         out.push({
             kind: "exprStmt",
-            expr: { kind: "libCall", fn: "readable.pushEncoding", args: [thisRef(), strLit(parsed.pushEncoding, loc)], type: thisType, loc },
+            expr: {
+                kind: "libCall",
+                fn: "readable.pushEncoding",
+                args: [thisRef(), strLit(parsed.pushEncoding, loc)],
+                type: thisType,
+                loc,
+            },
             loc,
         });
     }
     if (parsed.encoding !== null) {
         out.push({
             kind: "exprStmt",
-            expr: { kind: "libCall", fn: "readable.setEncoding", args: [thisRef(), strLit(parsed.encoding, loc)], type: thisType, loc },
+            expr: {
+                kind: "libCall",
+                fn: "readable.setEncoding",
+                args: [thisRef(), strLit(parsed.encoding, loc)],
+                type: thisType,
+                loc,
+            },
             loc,
         });
     }
@@ -957,11 +1061,13 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     if (ts.isIdentifier(access.expression)) {
         symbol = lowerer.resolveValueSymbol(access.expression);
     }
-    else if (ts.isPropertyAccessExpression(access.expression) && ts.isIdentifier(access.expression.name)) {
+    else if (ts.isPropertyAccessExpression(access.expression) &&
+        ts.isIdentifier(access.expression.name)) {
         const memberSym = lowerer.checker.getSymbolAtLocation(access.expression.name);
-        symbol = memberSym && memberSym.flags & ts.SymbolFlags.Alias
-            ? lowerer.checker.getAliasedSymbol(memberSym)
-            : memberSym;
+        symbol =
+            memberSym && memberSym.flags & ts.SymbolFlags.Alias
+                ? lowerer.checker.getAliasedSymbol(memberSym)
+                : memberSym;
     }
     if (!symbol)
         return null;
@@ -974,8 +1080,11 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     // Readable.toWeb's type-option ladder (JS sources): a provably-invalid
     // `type` throws Node's ERR_INVALID_ARG_VALUE before any web stream
     // 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])) {
+    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) {
             if (ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "type") {
                 const t = lowerer.typeOf(p.initializer);
@@ -998,17 +1107,30 @@ export function lowerStreamStaticCall(lowerer, call, access) {
     }
     const srcT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
     const type = { kind: "object", className: "%Readable" };
-    if (srcT?.kind === "array" && (srcT.elem.kind === "string" || (srcT.elem.kind === "bytes" && srcT.elem.elem === "u8"))) {
+    if (srcT?.kind === "array" &&
+        (srcT.elem.kind === "string" || (srcT.elem.kind === "bytes" && srcT.elem.elem === "u8"))) {
         const arr = lowerer.lowerExpr(args[0]);
         const strings = srcT.elem.kind === "string";
-        return { kind: "libCall", fn: "readable.fromArr", args: [arr, boolLit(strings, loc)], type, loc };
+        return {
+            kind: "libCall",
+            fn: "readable.fromArr",
+            args: [arr, boolLit(strings, loc)],
+            type,
+            loc,
+        };
     }
     if (srcT?.kind === "string" || (srcT?.kind === "bytes" && srcT.elem === "u8")) {
         // Node special-cases a single string/Buffer: ONE whole chunk.
         const v = lowerer.lowerExpr(args[0]);
         const strings = srcT.kind === "string";
         const arr = { kind: "arrayLit", elems: [v], type: arrayOf(v.type), loc };
-        return { kind: "libCall", fn: "readable.fromArr", args: [arr, boolLit(strings, loc)], type, loc };
+        return {
+            kind: "libCall",
+            fn: "readable.fromArr",
+            args: [arr, boolLit(strings, loc)],
+            type,
+            loc,
+        };
     }
     lowerer.noLowering(`Readable.from over a '${srcT ? lowerer.fmt(srcT) : "?"}' source`, args[0], "string[] / Buffer[] arrays (and a single string or Buffer) are the supported sources — generators and async iterables have no lowering yet");
 }
@@ -1071,13 +1193,20 @@ function lowerStreamArg(lowerer, node, what) {
                 // they take the pointed fence below, never a throw.
                 const pairish = v.type.kind === "record" &&
                     (lowerer.shapes.get(v.type.shapeId)?.fields ?? []).some((f) => f.name === "readable" || f.name === "writable");
-                if ((v.type.kind === "record" && !pairish) || v.type.kind === "f64" ||
-                    v.type.kind === "bool" || v.type.kind === "nullT") {
+                if ((v.type.kind === "record" && !pairish) ||
+                    v.type.kind === "f64" ||
+                    v.type.kind === "bool" ||
+                    v.type.kind === "nullT") {
                     argTypeThrow("body", PIPELINE_STAGE_EXPECTED);
                 }
             }
-            else if ((ts.isObjectLiteralExpression(node) && node.properties.length === 0) || v.type.kind === "record" || v.type.kind === "string" || v.type.kind === "f64" ||
-                v.type.kind === "bool" || v.type.kind === "array" || v.type.kind === "nullT") {
+            else if ((ts.isObjectLiteralExpression(node) && node.properties.length === 0) ||
+                v.type.kind === "record" ||
+                v.type.kind === "string" ||
+                v.type.kind === "f64" ||
+                v.type.kind === "bool" ||
+                v.type.kind === "array" ||
+                v.type.kind === "nullT") {
                 argTypeThrow("stream", "an instance of ReadableStream, WritableStream, or Stream");
             }
         }
@@ -1116,8 +1245,10 @@ function lowerEosCallback(lowerer, which, node, thisType) {
             const p0 = funcType.params[0];
             if (p0?.kind === "union") {
                 const def = lowerer.unions.get(p0.unionId);
-                if (def && def.arms.some((a) => a.kind === "object" && a.className === "%Error") &&
-                    def.arms.every((a) => a.kind === "nullT" || a.kind === "undefinedT" ||
+                if (def &&
+                    def.arms.some((a) => a.kind === "object" && a.className === "%Error") &&
+                    def.arms.every((a) => a.kind === "nullT" ||
+                        a.kind === "undefinedT" ||
                         (a.kind === "object" && a.className === "%Error"))) {
                     tuple = [p0];
                 }
@@ -1166,7 +1297,9 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
         // through the promise instead). The options argument has no lowering.
         if (bi.member === "finished") {
             if (args.length !== 1) {
-                lowerer.noLowering(`stream/promises.finished with ${args.length} arguments`, call, args.length === 2 ? "the options argument has no lowering yet — the one-argument form is supported" : "the supported form is finished(stream)");
+                lowerer.noLowering(`stream/promises.finished with ${args.length} arguments`, call, args.length === 2
+                    ? "the options argument has no lowering yet — the one-argument form is supported"
+                    : "the supported form is finished(stream)");
             }
             let recv;
             try {
@@ -1177,7 +1310,13 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
                     return e.expr;
                 throw e;
             }
-            return { kind: "libCall", fn: "sp.finished", args: [recv], type: { kind: "promise", inner: VOID }, loc };
+            return {
+                kind: "libCall",
+                fn: "sp.finished",
+                args: [recv],
+                type: { kind: "promise", inner: VOID },
+                loc,
+            };
         }
         // pipeline(...streams) → the callback pipeline's chaining/destroyer
         // semantics with the settlement on a promise. Stream stages only
@@ -1228,7 +1367,9 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
             // provable case takes the named fence instead.
             const argV = lowerer.lowerExpr(args[0]);
             const argInfo = argV.type.kind === "object" ? lowerer.classes.get(argV.type.className) : undefined;
-            if (argV.type.kind !== "dyn" && argV.type.kind !== "jsval" && !streamSidesOf(lowerer, argInfo)) {
+            if (argV.type.kind !== "dyn" &&
+                argV.type.kind !== "jsval" &&
+                !streamSidesOf(lowerer, argInfo)) {
                 lowerer.noLowering(`stream/consumers.${bi.member} over a value that is not a stream`, call, "Node rejects the promise with 'stream is not async iterable' — pass a readable stream");
             }
             const recv = argV;
@@ -1260,7 +1401,9 @@ export function lowerStreamModuleCall(lowerer, call, bi, loc) {
     }
     if (bi.member === "finished") {
         if (args.length !== 2) {
-            lowerer.noLowering(`finished with ${args.length} arguments`, call, args.length === 3 ? "the options argument has no lowering yet — the two-argument form is supported" : "the supported form is finished(stream, callback)");
+            lowerer.noLowering(`finished with ${args.length} arguments`, call, args.length === 3
+                ? "the options argument has no lowering yet — the two-argument form is supported"
+                : "the supported form is finished(stream, callback)");
         }
         let recv;
         try {
@@ -1355,7 +1498,8 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         }
         if (t?.kind === "union") {
             const def = lowerer.unions.get(t.unionId);
-            if (def && def.arms.every((a) => (a.kind === "bytes" && a.elem === "u8") || a.kind === "string" || a.kind === "nullT")) {
+            if (def &&
+                def.arms.every((a) => (a.kind === "bytes" && a.elem === "u8") || a.kind === "string" || a.kind === "nullT")) {
                 return "union";
             }
         }
@@ -1378,7 +1522,7 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
     if (member === "push" || member === "unshift") {
         requireSide(readableSide, member);
         if (args.length === 0 || args.length > 2) {
-            lowerer.noLowering(`${member} with ${args.length} arguments`, call, "the supported forms are (chunk) and (chunk, \"utf8\")");
+            lowerer.noLowering(`${member} with ${args.length} arguments`, call, 'the supported forms are (chunk) and (chunk, "utf8")');
         }
         // push(chunk, enc) with a LITERAL encoding: the per-call decode
         // (Buffer.from(chunk, enc)) — an explicit encoding (utf8 included)
@@ -1427,15 +1571,33 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 return { kind: "libCall", fn: "readable.push", args: [receiver, chunk], type: BOOL, loc };
             }
             if (chunk.type.kind === "string") {
-                return { kind: "libCall", fn: "readable.pushStr", args: [receiver, chunk], type: BOOL, loc };
+                return {
+                    kind: "libCall",
+                    fn: "readable.pushStr",
+                    args: [receiver, chunk],
+                    type: BOOL,
+                    loc,
+                };
             }
             return { kind: "libCall", fn: "readable.pushNull", args: [receiver], type: BOOL, loc };
         }
-        const chunk = kind === "bytes" ? lowerer.lowerExprExpecting(args[0], BYTES) : lowerer.lowerExprExpecting(args[0], STRING);
+        const chunk = kind === "bytes"
+            ? lowerer.lowerExprExpecting(args[0], BYTES)
+            : lowerer.lowerExprExpecting(args[0], STRING);
         const fn = member === "push"
-            ? (kind === "bytes" ? "readable.push" : "readable.pushStr")
-            : (kind === "bytes" ? "readable.unshift" : "readable.unshiftStr");
-        return { kind: "libCall", fn, args: [receiver, chunk], type: member === "push" ? BOOL : VOID, loc };
+            ? kind === "bytes"
+                ? "readable.push"
+                : "readable.pushStr"
+            : kind === "bytes"
+                ? "readable.unshift"
+                : "readable.unshiftStr";
+        return {
+            kind: "libCall",
+            fn,
+            args: [receiver, chunk],
+            type: member === "push" ? BOOL : VOID,
+            loc,
+        };
     }
     if (member === "read") {
         requireSide(readableSide, "read");
@@ -1444,7 +1606,13 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         const receiver = lowerer.lowerExpr(access.expression);
         const size = args[0] ? lowerer.lowerExprExpecting(args[0], F64) : numLit(-1, loc);
         const type = unionOf(lowerer, [BYTES, { kind: "nullT" }]);
-        const read = { kind: "libCall", fn: "readable.read", args: [receiver, size], type, loc };
+        const read = {
+            kind: "libCall",
+            fn: "readable.read",
+            args: [receiver, size],
+            type,
+            loc,
+        };
         return lowerer.maybeNarrow(read, call);
     }
     if (member === "pause" || member === "resume") {
@@ -1452,7 +1620,13 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         if (args.length !== 0)
             lowerer.noLowering(`${member} with arguments`, call);
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: member === "pause" ? "readable.pause" : "readable.resume", args: [receiver], type: receiver.type, loc };
+        return {
+            kind: "libCall",
+            fn: member === "pause" ? "readable.pause" : "readable.resume",
+            args: [receiver],
+            type: receiver.type,
+            loc,
+        };
     }
     if (member === "isPaused") {
         requireSide(readableSide, "isPaused");
@@ -1478,14 +1652,22 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 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") {
+                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);
             }
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: "readable.pipe", args: [receiver, dst, end], type: dst.type, loc };
+        return {
+            kind: "libCall",
+            fn: "readable.pipe",
+            args: [receiver, dst, end],
+            type: dst.type,
+            loc,
+        };
     }
     if (member === "unpipe") {
         requireSide(readableSide, "unpipe");
@@ -1499,7 +1681,13 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             if (dstSides !== "w" && dstSides !== "rw") {
                 lowerer.noLowering(`unpipe of a '${lowerer.fmt(dst.type)}'`, args[0]);
             }
-            return { kind: "libCall", fn: "readable.unpipe", args: [receiver, dst], type: receiver.type, loc };
+            return {
+                kind: "libCall",
+                fn: "readable.unpipe",
+                args: [receiver, dst],
+                type: receiver.type,
+                loc,
+            };
         }
         return { kind: "libCall", fn: "readable.unpipe", args: [receiver], type: receiver.type, loc };
     }
@@ -1521,7 +1709,13 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             if (!rootsAtError(err.type)) {
                 lowerer.noLowering(`destroy with a '${lowerer.fmt(err.type)}' argument`, args[0], "the supported argument is an Error-hierarchy instance");
             }
-            return { kind: "libCall", fn: "stream.destroyErr", args: [receiver, lowerer.upcastTo(err, "%Error")], type: receiver.type, loc };
+            return {
+                kind: "libCall",
+                fn: "stream.destroyErr",
+                args: [receiver, lowerer.upcastTo(err, "%Error")],
+                type: receiver.type,
+                loc,
+            };
         }
         return { kind: "libCall", fn: "stream.destroy", args: [receiver], type: receiver.type, loc };
     }
@@ -1549,8 +1743,11 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
                 lowerer.noLowering("write with a union chunk and more arguments", call);
             const receiver = lowerer.lowerExpr(access.expression);
             const chunk = lowerer.lowerExpr(args[0]);
-            const fn = chunk.type.kind === "union" ? "writable.writeU"
-                : chunk.type.kind === "string" ? "writable.writeStr" : "writable.write";
+            const fn = chunk.type.kind === "union"
+                ? "writable.writeU"
+                : chunk.type.kind === "string"
+                    ? "writable.writeStr"
+                    : "writable.write";
             if (chunk.type.kind === "nullT")
                 lowerer.noLowering("write(null)", call, "end() finishes a writable");
             return { kind: "libCall", fn, args: [receiver, chunk], type: BOOL, loc };
@@ -1570,7 +1767,9 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             cbArg = args[2];
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        const chunk = kind === "bytes" ? lowerer.lowerExprExpecting(args[0], BYTES) : lowerer.lowerExprExpecting(args[0], STRING);
+        const chunk = kind === "bytes"
+            ? lowerer.lowerExprExpecting(args[0], BYTES)
+            : lowerer.lowerExprExpecting(args[0], STRING);
         const fn = kind === "bytes" ? "writable.write" : "writable.writeStr";
         if (cbArg !== undefined) {
             const cb = lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
@@ -1616,8 +1815,10 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             if (kind === "null" || kind === "union")
                 lowerer.noLowering("end(null)", call);
             flags |= kind === "bytes" ? 1 : kind === "dyn" ? 8 : 2;
-            tail.push(kind === "bytes" ? lowerer.lowerExprExpecting(chunkNode, BYTES)
-                : kind === "dyn" ? lowerer.lowerExprExpecting(chunkNode, DYN)
+            tail.push(kind === "bytes"
+                ? lowerer.lowerExprExpecting(chunkNode, BYTES)
+                : kind === "dyn"
+                    ? lowerer.lowerExprExpecting(chunkNode, DYN)
                     : lowerer.lowerExprExpecting(chunkNode, STRING));
         }
         if (cbArg !== undefined) {
@@ -1628,14 +1829,26 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
             flags |= 4;
             tail.push(cb);
         }
-        return { kind: "libCall", fn: "writable.end", args: [receiver, numLit(flags, loc), ...tail], type: receiver.type, loc };
+        return {
+            kind: "libCall",
+            fn: "writable.end",
+            args: [receiver, numLit(flags, loc), ...tail],
+            type: receiver.type,
+            loc,
+        };
     }
     if (member === "cork" || member === "uncork") {
         requireSide(writableSide, member);
         if (args.length !== 0)
             lowerer.noLowering(`${member} with arguments`, call);
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: member === "cork" ? "writable.cork" : "writable.uncork", args: [receiver], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: member === "cork" ? "writable.cork" : "writable.uncork",
+            args: [receiver],
+            type: VOID,
+            loc,
+        };
     }
     if (member === "setEncoding") {
         requireSide(readableSide, "setEncoding");
@@ -1644,7 +1857,13 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
         }
         const enc = bufEncoding(lowerer, "setEncoding", args[0]);
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: "readable.setEncoding", args: [receiver, strLit(enc, loc)], type: receiver.type, loc };
+        return {
+            kind: "libCall",
+            fn: "readable.setEncoding",
+            args: [receiver, strLit(enc, loc)],
+            type: receiver.type,
+            loc,
+        };
     }
     if (member === "setDefaultEncoding") {
         // The write-side default: utf8 IS the default — admit it; other
@@ -1668,17 +1887,37 @@ export function lowerStreamMethodCall(lowerer, call, access, info) {
  * the per-side errored slots collapse onto the shared fields here
  * (SEMANTICS.md). */
 const RS_BOOL_PROPS = new Set([
-    "ended", "endEmitted", "destroyed", "errorEmitted", "emittedReadable",
-    "needReadable", "reading", "readableListening", "resumeScheduled",
-    "objectMode", "constructed", "closed",
+    "ended",
+    "endEmitted",
+    "destroyed",
+    "errorEmitted",
+    "emittedReadable",
+    "needReadable",
+    "reading",
+    "readableListening",
+    "resumeScheduled",
+    "objectMode",
+    "constructed",
+    "closed",
 ]);
 const RS_NUM_PROPS = new Set(["length", "highWaterMark"]);
 const WS_BOOL_PROPS = new Set([
-    "ended", "ending", "finished", "destroyed", "errorEmitted", "needDrain",
-    "objectMode", "constructed", "closed", "prefinished",
+    "ended",
+    "ending",
+    "finished",
+    "destroyed",
+    "errorEmitted",
+    "needDrain",
+    "objectMode",
+    "constructed",
+    "closed",
+    "prefinished",
 ]);
 const WS_NUM_PROPS = new Set([
-    "length", "highWaterMark", "corked", "bufferedRequestCount",
+    "length",
+    "highWaterMark",
+    "corked",
+    "bufferedRequestCount",
 ]);
 export function lowerStreamStateProperty(lowerer, expr) {
     if (expr.questionDotToken)
@@ -1716,7 +1955,10 @@ export function lowerStreamStateProperty(lowerer, expr) {
         return lowerer.maybeNarrow(read, expr);
     }
     if (name === "errored") {
-        const type = unionOf(lowerer, [{ kind: "object", className: "%Error" }, { kind: "nullT" }]);
+        const type = unionOf(lowerer, [
+            { kind: "object", className: "%Error" },
+            { kind: "nullT" },
+        ]);
         const read = { kind: "libCall", fn: "stream.errored", args: [receiver()], type, loc };
         return lowerer.maybeNarrow(read, expr);
     }
@@ -1735,10 +1977,22 @@ export function lowerStreamStateProperty(lowerer, expr) {
 }
 /* ── the property surface ─────────────────────────────────────────────── */
 const READABLE_BOOL_PROPS = new Set(["readable", "readableEnded"]);
-const WRITABLE_BOOL_PROPS = new Set(["writable", "writableEnded", "writableFinished", "writableNeedDrain"]);
+const WRITABLE_BOOL_PROPS = new Set([
+    "writable",
+    "writableEnded",
+    "writableFinished",
+    "writableNeedDrain",
+]);
 const SHARED_BOOL_PROPS = new Set(["destroyed", "closed"]);
-const READABLE_NUM_PROPS = new Set(["readableLength", "readableHighWaterMark"]);
-const WRITABLE_NUM_PROPS = new Set(["writableLength", "writableHighWaterMark", "writableCorked"]);
+const READABLE_NUM_PROPS = new Set([
+    "readableLength",
+    "readableHighWaterMark",
+]);
+const WRITABLE_NUM_PROPS = new Set([
+    "writableLength",
+    "writableHighWaterMark",
+    "writableCorked",
+]);
 /** Property reads on stream-rooted receivers (`r.readableEnded`,
  * `w.destroyed`, ...). Null for names this spoke does not own. */
 export function lowerStreamProperty(lowerer, expr, info) {
@@ -1756,20 +2010,38 @@ export function lowerStreamProperty(lowerer, expr, info) {
         type,
         loc,
     });
-    if ((readableSide && READABLE_BOOL_PROPS.has(name)) || (writableSide && WRITABLE_BOOL_PROPS.has(name)) || SHARED_BOOL_PROPS.has(name)) {
+    if ((readableSide && READABLE_BOOL_PROPS.has(name)) ||
+        (writableSide && WRITABLE_BOOL_PROPS.has(name)) ||
+        SHARED_BOOL_PROPS.has(name)) {
         return propCall(BOOL);
     }
-    if ((readableSide && READABLE_NUM_PROPS.has(name)) || (writableSide && WRITABLE_NUM_PROPS.has(name))) {
+    if ((readableSide && READABLE_NUM_PROPS.has(name)) ||
+        (writableSide && WRITABLE_NUM_PROPS.has(name))) {
         return propCall(F64);
     }
     if (name === "readableFlowing" && readableSide) {
         const type = unionOf(lowerer, [BOOL, { kind: "nullT" }]);
-        const read = { kind: "libCall", fn: "readable.flowing", args: [lowerer.lowerExpr(expr.expression)], type, loc };
+        const read = {
+            kind: "libCall",
+            fn: "readable.flowing",
+            args: [lowerer.lowerExpr(expr.expression)],
+            type,
+            loc,
+        };
         return lowerer.maybeNarrow(read, expr);
     }
     if (name === "errored") {
-        const type = unionOf(lowerer, [{ kind: "object", className: "%Error" }, { kind: "nullT" }]);
-        const read = { kind: "libCall", fn: "stream.errored", args: [lowerer.lowerExpr(expr.expression)], type, loc };
+        const type = unionOf(lowerer, [
+            { kind: "object", className: "%Error" },
+            { kind: "nullT" },
+        ]);
+        const read = {
+            kind: "libCall",
+            fn: "stream.errored",
+            args: [lowerer.lowerExpr(expr.expression)],
+            type,
+            loc,
+        };
         return lowerer.maybeNarrow(read, expr);
     }
     if (name === "readableObjectMode" && readableSide) {