@scriptc/compiler 0.0.35 → 0.1.1

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

@@ -1,5 +1,6 @@
+import { InternalCompilerError } from "../../errors.js";
 /* The node:stream lowering (the spoke-module pattern, like
- * lower-emitter.ts): construction of the five runtime stream classes
+ * lower-event-emitter.ts): construction of the five runtime stream classes
  * (`new Readable({ read() {} })` et al — the OPTIONS-OBJECT form), user
  * subclasses (`class My extends Readable { _read() {...} }` — the
  * underscore-override form: super(options) lowers to a stream.init
@@ -33,11 +34,12 @@ import { newFnCtx, own } from "./lowerer.js";
 import { appendImplicitUndefinedReturn } from "./lower-calls.js";
 import { bufEncoding, knownBufEncoding } from "./lower-containers.js";
 import { probeLower } from "./lower-exprs.js";
-import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, bytesOf, canBoxFuncIntoDyn, funcOf, typeEquals, typeKey } from "../../ir/nodes.js";
+import { BOOL, DYN, F64, RUNTIME_STREAM_CLASSES, STRING, VOID, arrayOf, bytesOf, canBoxFuncIntoDyn, funcOf, typeEquals, typeKey } from "../../ir/ir.js";
+import { boolLit, numLit, strLit } from "../../ir/build.js";
 const BYTES = bytesOf("u8");
 /** The stream sides of a receiver class: the nearest stream-class
  * ancestor's, or null off the stream hierarchy. */
-export function streamSidesOf(L, info) {
+export function streamSidesOf(lowerer, info) {
     for (let c = info ?? null; c; c = c.base) {
         if (c.builtinStream)
             return c.builtinStream;
@@ -90,15 +92,15 @@ export function streamCtorShape(cls) {
         case "%PassThrough":
             return { fn: "passthrough", accepted: ["transform", "flush", "destroy"], duplexShape: true };
         default:
-            throw new Error(`lowerer bug: streamCtorShape of ${cls}`);
+            throw new InternalCompilerError(`lowerer bug: streamCtorShape of ${cls}`);
     }
 }
 /** The per-base FORCED event tuples (runtime-emitted payloads): consulted
  * by the emitter spoke BEFORE the program-global table, so a stream's
  * 'data' never collides with a user event named 'data' on a plain
  * emitter. 'error' stays globally forced to the one-%Error tuple. */
-export function streamForcedTuple(L, info, name) {
-    const sides = streamSidesOf(L, info);
+export function streamForcedTuple(lowerer, info, name) {
+    const sides = streamSidesOf(lowerer, info);
     if (!sides)
         return null;
     const readable = {
@@ -130,9 +132,6 @@ export function streamForcedTuple(L, info, name) {
     }
     return null;
 }
-const strLit = (value, loc) => ({ kind: "strLit", value, type: STRING, loc });
-const boolLit = (value, loc) => ({ kind: "boolLit", value, type: BOOL, loc });
-const f64Lit = (value, loc) => ({ kind: "numLit", value, type: F64, loc });
 /* ── option callbacks (the leading-`this` closures) ─────────────────── */
 /** Lowers one option callback (method shorthand, function expression, or
  * arrow) into a closure whose lifted function takes the STREAM as a
@@ -140,14 +139,14 @@ const f64Lit = (value, loc) => ({ kind: "numLit", value, type: F64, loc });
  * (Node calls them stream-bound); arrows keep lexical `this` (the hidden
  * leading param is ABI-only). The declared parameters must be a
  * typeEquals PREFIX of the callback's Node signature. */
-function lowerStreamCallback(L, which, node, thisType, fullTuple) {
+function lowerStreamCallback(lowerer, which, node, thisType, fullTuple) {
     const loc = locOf(node);
-    const { shapes, funcType } = L.lambdaSignature(node);
+    const { shapes, funcType } = lowerer.lambdaSignature(node);
     if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
-        L.unsupported("SC1090", node, `async stream '${which}' callbacks`);
+        lowerer.unsupported("SC1090", node, `async stream '${which}' callbacks`);
     }
     if (funcType.params.length > fullTuple.length) {
-        L.noLowering(`a '${which}' callback declaring ${funcType.params.length} parameters where Node passes ${fullTuple.length}`, node, "stream option callbacks may declare a prefix of their Node signature");
+        lowerer.noLowering(`a '${which}' callback declaring ${funcType.params.length} parameters where Node passes ${fullTuple.length}`, node, "stream option callbacks may declare a prefix of their Node signature");
     }
     for (let i = 0; i < funcType.params.length; i++) {
         // A checked-dynamic parameter (the JS lane's implicitly-any
@@ -157,23 +156,23 @@ function lowerStreamCallback(L, which, node, thisType, fullTuple) {
         if (funcType.params[i].kind === "dyn")
             continue;
         if (!typeEquals(funcType.params[i], fullTuple[i])) {
-            L.noLowering(`a '${which}' callback whose parameter ${i} is '${L.fmt(funcType.params[i])}' where Node passes '${L.fmt(fullTuple[i])}'`, node, "annotate the parameter with the Node signature's type (chunks are Buffers here)");
+            lowerer.noLowering(`a '${which}' callback whose parameter ${i} is '${lowerer.fmt(funcType.params[i])}' where Node passes '${lowerer.fmt(fullTuple[i])}'`, node, "annotate the parameter with the Node signature's type (chunks are Buffers here)");
         }
     }
-    const fnName = `%fn${L.lambdaCounter++}_${which}cb`;
+    const fnName = `%fn${lowerer.lambdaCounter++}_${which}cb`;
     const fnCtx = newFnCtx(true, null, funcType, funcType.ret);
-    L.fnStack.push(fnCtx);
+    lowerer.fnStack.push(fnCtx);
     try {
         // Method shorthand and function expressions see the stream as `this`
         // (Node binds it); arrows keep lexical `this`, so their slot is a
         // hidden ABI local no body reference can resolve to.
         const thisLocal = ts.isArrowFunction(node)
-            ? L.declareHiddenLocal("this", thisType)
-            : L.declareThis(thisType);
-        const { params, prologue } = L.declareParams(node.parameters, shapes);
+            ? lowerer.declareHiddenLocal("this", thisType)
+            : lowerer.declareThis(thisType);
+        const { params, prologue } = lowerer.declareParams(node.parameters, shapes);
         let body;
         if (node.body !== undefined && ts.isBlock(node.body)) {
-            body = L.lowerStmts(node.body.statements);
+            body = lowerer.lowerStmts(node.body.statements);
         }
         else if (node.body !== undefined) {
             // Bare-expression bodies (`read: () => this.push(null)`): the value
@@ -181,19 +180,19 @@ function lowerStreamCallback(L, which, node, thisType, fullTuple) {
             // option-callback results either way.
             const bodyExpr = node.body;
             if (funcType.ret.kind === "void") {
-                body = [{ kind: "exprStmt", expr: L.lowerExpr(bodyExpr), loc: locOf(node.body) }];
+                body = [{ kind: "exprStmt", expr: lowerer.lowerExpr(bodyExpr), loc: locOf(node.body) }];
             }
             else {
-                const value = L.lowerExpr(bodyExpr);
-                body = [{ kind: "return", value: L.coerceInto(bodyExpr, value, funcType.ret), loc: locOf(node.body) }];
+                const value = lowerer.lowerExpr(bodyExpr);
+                body = [{ kind: "return", value: lowerer.coerceInto(bodyExpr, value, funcType.ret), loc: locOf(node.body) }];
             }
         }
         else {
             body = [];
         }
         body = [...prologue, ...body];
-        appendImplicitUndefinedReturn(L, body, funcType.ret, loc);
-        const ctx = L.ctx;
+        appendImplicitUndefinedReturn(lowerer, body, funcType.ret, loc);
+        const ctx = lowerer.ctx;
         const lifted = {
             name: fnName,
             params: [{ localId: thisLocal.id, name: "this", type: thisType }, ...params],
@@ -203,7 +202,7 @@ function lowerStreamCallback(L, which, node, thisType, fullTuple) {
             body,
             loc,
         };
-        L.liftedFns.push(lifted);
+        lowerer.liftedFns.push(lifted);
         return {
             kind: "closure",
             fnName,
@@ -213,7 +212,7 @@ function lowerStreamCallback(L, which, node, thisType, fullTuple) {
         };
     }
     finally {
-        L.fnStack.pop();
+        lowerer.fnStack.pop();
     }
 }
 /** The full Node parameter tuples of the option callbacks, given the
@@ -221,32 +220,32 @@ function lowerStreamCallback(L, which, node, thisType, fullTuple) {
  * whatever func type the checker contextually gave the user's parameter
  * (the emitted adapter constructs a matching closure), so only their
  * FUNC-ness is checked here. */
-function cbTuples(L) {
+function cbTuples(lowerer) {
     return {
         read: [F64],
         write: [BYTES, STRING, "fn"],
         final: ["fn"],
-        destroy: [errorOrNull(L), "fn"],
+        destroy: [errorOrNull(lowerer), "fn"],
         transform: [BYTES, STRING, "fn"],
         flush: ["fn"],
     };
 }
 /** Interns a union from unsorted arms (the interner's identity is the
  * typeKey-SORTED arm list — mapType's canonicalization). */
-function unionOf(L, arms) {
+function unionOf(lowerer, arms) {
     const sorted = [...arms].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
-    return { kind: "union", unionId: L.unions.intern(sorted) };
+    return { kind: "union", unionId: lowerer.unions.intern(sorted) };
 }
-function errorOrNull(L) {
-    return unionOf(L, [{ kind: "object", className: "%Error" }, { kind: "nullT" }]);
+function errorOrNull(lowerer) {
+    return unionOf(lowerer, [{ kind: "object", className: "%Error" }, { kind: "nullT" }]);
 }
 /** The program's property-mutated symbols (`opts.read = f`, `opts["x"]
  * op= v`, `delete opts.y`): a const-initialized options record whose
  * symbol appears here cannot be followed to its literal — the runtime
  * record and the compile-time walk would split-brain. Built once, lazily
  * (the emitterEvents pre-pass precedent); the scan is diagnostic-free. */
-function propMutatedSymbols(L) {
-    const holder = L;
+function propMutatedSymbols(lowerer) {
+    const holder = lowerer;
     if (holder.streamPropMutatedSyms)
         return holder.streamPropMutatedSyms;
     const set = new Set();
@@ -258,7 +257,7 @@ function propMutatedSymbols(L) {
         if (!ts.isIdentifier(base))
             return;
         try {
-            const sym = L.resolveValueSymbol(base);
+            const sym = lowerer.resolveValueSymbol(base);
             if (sym)
                 set.add(sym);
         }
@@ -266,7 +265,7 @@ function propMutatedSymbols(L) {
             /* not a candidate */
         }
     };
-    for (const sf of L.program.getSourceFiles()) {
+    for (const sf of lowerer.program.getSourceFiles()) {
         if (sf.isDeclarationFile)
             continue;
         const walk = (node) => {
@@ -297,7 +296,7 @@ function propMutatedSymbols(L) {
  * (propMutatedSymbols). Returns the argument unchanged when the chain
  * breaks; `undefined`/null arguments answer null (Node's `if (options)`
  * guard — all defaults). */
-function followOptionsArg(L, arg) {
+function followOptionsArg(lowerer, arg) {
     let node = arg;
     for (let hops = 0; node !== undefined && hops < 16; hops++) {
         if (ts.isObjectLiteralExpression(node))
@@ -314,17 +313,17 @@ function followOptionsArg(L, arg) {
             return null;
         let sym;
         try {
-            sym = L.resolveValueSymbol(node);
+            sym = lowerer.resolveValueSymbol(node);
         }
         catch {
             return node;
         }
-        const decl = sym ? L.checker.valueDeclarationOf(sym) : undefined;
+        const decl = sym ? lowerer.checker.valueDeclarationOf(sym) : undefined;
         if (!sym || !decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined)
             return node;
         if ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) === 0)
             return node;
-        if (propMutatedSymbols(L).has(sym))
+        if (propMutatedSymbols(lowerer).has(sym))
             return node;
         node = decl.initializer;
     }
@@ -343,32 +342,32 @@ function followOptionsArg(L, arg) {
  * calls option callbacks; a value adapted through the dyn boundary is
  * called with `this` undefined (the dyn call ABI carries no receiver) —
  * reference the stream through a lexical binding instead. */
-function lowerStreamCallbackValue(L, ctorName, which, node, fullLen) {
+function lowerStreamCallbackValue(lowerer, ctorName, which, node, fullLen) {
     const loc = locOf(node);
-    const getRecord = (id) => L.shapes.get(id);
-    const getUnion = (id) => L.unions.get(id);
+    const getRecord = (id) => lowerer.shapes.get(id);
+    const getUnion = (id) => lowerer.unions.get(id);
     let t;
     try {
-        const ct = L.typeOf(node);
-        t = L.mapTypeOf(ct) ?? dynFallbackType(L, node, ct);
+        const ct = lowerer.typeOf(node);
+        t = lowerer.mapTypeOf(ct) ?? dynFallbackType(lowerer, node, ct);
     }
     catch {
         t = null;
     }
     let cbDyn;
     if (t?.kind === "dyn") {
-        const v = L.lowerExpr(node);
+        const v = lowerer.lowerExpr(node);
         cbDyn = v.type.kind === "dyn" ? v : { kind: "dynFrom", value: v, type: DYN, loc };
     }
     else if (t?.kind === "func") {
-        const cb = L.lowerExpr(node);
+        const cb = lowerer.lowerExpr(node);
         if (cb.type.kind !== "func" || !canBoxFuncIntoDyn(cb.type, getRecord, getUnion)) {
-            L.noLowering(`the ${ctorName} option '${which}' with a function value of this signature`, node, "a callback value's own parameters and return must cross the checked-dynamic boundary — write the callback inline to keep it fully static");
+            lowerer.noLowering(`the ${ctorName} option '${which}' with a function value of this signature`, node, "a callback value's own parameters and return must cross the checked-dynamic boundary — write the callback inline to keep it fully static");
         }
         cbDyn = { kind: "dynFrom", value: cb, type: DYN, loc };
     }
     else {
-        L.noLowering(`the ${ctorName} option '${which}' with a non-function value`, node, "the callback slot takes an inline function (fully static) or a function value that crosses the checked-dynamic boundary");
+        lowerer.noLowering(`the ${ctorName} option '${which}' with a non-function value`, node, "the callback slot takes an inline function (fully static) or a function value that crosses the checked-dynamic boundary");
     }
     const adapterT = funcOf(Array.from({ length: fullLen }, () => DYN), VOID);
     return { kind: "dynCheck", value: cbDyn, type: adapterT, loc };
@@ -378,34 +377,34 @@ function lowerStreamCallbackValue(L, ctorName, which, node, fullLen) {
  * record's shape is runtime data, so the option walk runs in the runtime
  * (the `.newDyn`/`.initDyn` twins) with Node's own reading rules. Null
  * when the argument is not dyn-flavored (the static walk owns it). */
-function dynOptionsValue(L, arg) {
-    const followed = followOptionsArg(L, arg);
+function dynOptionsValue(lowerer, arg) {
+    const followed = followOptionsArg(lowerer, arg);
     if (followed === null || followed === undefined || ts.isObjectLiteralExpression(followed))
         return null;
     let t;
     try {
-        const ct = L.typeOf(followed);
-        t = L.mapTypeOf(ct) ?? dynFallbackType(L, followed, ct);
+        const ct = lowerer.typeOf(followed);
+        t = lowerer.mapTypeOf(ct) ?? dynFallbackType(lowerer, followed, ct);
     }
     catch {
         return null;
     }
     if (t?.kind !== "dyn")
         return null;
-    const v = L.lowerExpr(followed);
+    const v = lowerer.lowerExpr(followed);
     return v.type.kind === "dyn" ? v : null;
 }
 /** Parses the options object literal of a stream constructor. `which`
  * names the callbacks this class accepts, in canonical flag order. */
-function parseStreamOptions(L, ctorName, arg, thisType, accepted, loc, 
+function parseStreamOptions(lowerer, ctorName, arg, thisType, accepted, loc, 
 /** Subclass construction: the wrapper closure for an overridden
  * underscore method, consulted for callbacks the options did not
  * provide (an options callback shadows the method, Node's instance-
  * property rule). */
 fallbackCb) {
     const out = {
-        hwmR: f64Lit(-1, loc),
-        hwmW: f64Lit(-1, loc),
+        hwmR: numLit(-1, loc),
+        hwmW: numLit(-1, loc),
         autoDestroy: boolLit(true, loc),
         emitClose: boolLit(true, loc),
         allowHalfOpen: boolLit(true, loc),
@@ -417,12 +416,12 @@ fallbackCb) {
         flags: 0,
         cbs: [],
     };
-    const followed = followOptionsArg(L, arg);
+    const followed = followOptionsArg(lowerer, arg);
     const optsLit = followed === null ? undefined : followed;
     if (optsLit !== undefined && !ts.isObjectLiteralExpression(optsLit)) {
-        L.noLowering(`new ${ctorName} with a non-literal options argument`, optsLit, "the options must be an object literal, inline or through const-initialized bindings (the callbacks lower as compile-time closures)");
+        lowerer.noLowering(`new ${ctorName} with a non-literal options argument`, optsLit, "the options must be an object literal, inline or through const-initialized bindings (the callbacks lower as compile-time closures)");
     }
-    const tuples = cbTuples(L);
+    const tuples = cbTuples(lowerer);
     const present = new Map();
     for (const prop of optsLit?.properties ?? []) {
         const propName = ts.isSpreadAssignment(prop) ? undefined : prop.name;
@@ -432,7 +431,7 @@ fallbackCb) {
                 ? propName.text
                 : null;
         if (name === null) {
-            L.unsupported("SC1090", prop, `computed or spread members in ${ctorName} options`);
+            lowerer.unsupported("SC1090", prop, `computed or spread members in ${ctorName} options`);
         }
         // Callback members: shorthand methods and function-valued properties.
         if (accepted.includes(name)) {
@@ -453,54 +452,54 @@ fallbackCb) {
                         ? prop.name
                         : null;
                 if (valueNode === null) {
-                    L.noLowering(`the ${ctorName} option '${name}' as this member form`, prop, "write the callback inline (method shorthand or an inline function/arrow), or pass a function value");
+                    lowerer.noLowering(`the ${ctorName} option '${name}' as this member form`, prop, "write the callback inline (method shorthand or an inline function/arrow), or pass a function value");
                 }
-                present.set(name, lowerStreamCallbackValue(L, ctorName, name, valueNode, tuples[name].length));
+                present.set(name, lowerStreamCallbackValue(lowerer, ctorName, name, valueNode, tuples[name].length));
                 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 } = L.lambdaSignature(fnNode);
+            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") {
-                    L.noLowering(`a '${name}' callback whose parameter ${i} is '${L.fmt(declared)}' where Node passes the completion callback`, fnNode);
+                    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(L, name, fnNode, thisType, tuple));
+            present.set(name, lowerStreamCallback(lowerer, name, fnNode, thisType, tuple));
             continue;
         }
         // Scalar options.
         if (!ts.isPropertyAssignment(prop)) {
-            L.unsupported("SC1090", prop, `the ${ctorName} option '${name}' as a shorthand/method member`);
+            lowerer.unsupported("SC1090", prop, `the ${ctorName} option '${name}' as a shorthand/method member`);
         }
         const value = prop.initializer;
         switch (name) {
             case "highWaterMark": {
-                const v = L.lowerExprExpecting(value, F64);
+                const v = lowerer.lowerExprExpecting(value, F64);
                 out.hwmR = v;
                 out.hwmW = v;
                 break;
             }
             case "readableHighWaterMark":
-                out.hwmR = L.lowerExprExpecting(value, F64);
+                out.hwmR = lowerer.lowerExprExpecting(value, F64);
                 break;
             case "writableHighWaterMark":
-                out.hwmW = L.lowerExprExpecting(value, F64);
+                out.hwmW = lowerer.lowerExprExpecting(value, F64);
                 break;
             case "autoDestroy":
-                out.autoDestroy = L.lowerExprExpecting(value, BOOL);
+                out.autoDestroy = lowerer.lowerExprExpecting(value, BOOL);
                 break;
             case "emitClose":
-                out.emitClose = L.lowerExprExpecting(value, BOOL);
+                out.emitClose = lowerer.lowerExprExpecting(value, BOOL);
                 break;
             case "allowHalfOpen":
-                out.allowHalfOpen = L.lowerExprExpecting(value, BOOL);
+                out.allowHalfOpen = lowerer.lowerExprExpecting(value, BOOL);
                 break;
             case "objectMode":
             case "readableObjectMode":
@@ -508,13 +507,13 @@ fallbackCb) {
                 // `objectMode: false` is the byte default — admit the literal.
                 if (value.kind === ts.SyntaxKind.FalseKeyword)
                     break;
-                L.noLowering(`${ctorName} in objectMode`, prop, "object-mode streams have no static chunk type yet — chunks are Buffers (utf8 strings convert at push/write)");
+                lowerer.noLowering(`${ctorName} in objectMode`, prop, "object-mode streams have no static chunk type yet — chunks are Buffers (utf8 strings convert at push/write)");
                 break;
             }
             case "decodeStrings": {
                 if (value.kind === ts.SyntaxKind.TrueKeyword)
                     break; // Node's default
-                L.noLowering(`${ctorName} with decodeStrings: false`, prop, "chunks always decode to Buffers here (Node's default)");
+                lowerer.noLowering(`${ctorName} with decodeStrings: false`, prop, "chunks always decode to Buffers here (Node's default)");
                 break;
             }
             case "encoding": {
@@ -523,15 +522,15 @@ fallbackCb) {
                 // spelling Node does not know is Node's RUNTIME rejection —
                 // ERR_UNKNOWN_ENCODING at construction, not a compile fence.
                 if (ctorName === "Writable")
-                    L.noLowering(`the Writable option 'encoding'`, prop);
+                    lowerer.noLowering(`the Writable option 'encoding'`, prop);
                 {
-                    const t = L.typeOf(value);
+                    const t = lowerer.typeOf(value);
                     if (t.isStringLiteralType() && knownBufEncoding(t.value) === undefined) {
                         out.badEncoding = t.value;
                         break;
                     }
                 }
-                out.encoding = bufEncoding(L, `the ${ctorName} option 'encoding'`, value);
+                out.encoding = bufEncoding(lowerer, `the ${ctorName} option 'encoding'`, value);
                 break;
             }
             case "defaultEncoding":
@@ -543,7 +542,7 @@ fallbackCb) {
                 // readable.pushEncoding. The write-side meaning (what
                 // write(string) does) stays fenced on the writable classes.
                 {
-                    const t = L.typeOf(value);
+                    const t = lowerer.typeOf(value);
                     if (t.isStringLiteralType() && (t.value === "utf8" || t.value === "utf-8"))
                         break;
                     if (t.isStringLiteralType() && knownBufEncoding(t.value) === undefined) {
@@ -555,10 +554,10 @@ fallbackCb) {
                         break;
                     }
                 }
-                L.noLowering(`the ${ctorName} option 'defaultEncoding'`, prop, "utf8 (the default) is the supported write-side string encoding");
+                lowerer.noLowering(`the ${ctorName} option 'defaultEncoding'`, prop, "utf8 (the default) is the supported write-side string encoding");
                 break;
             case "signal":
-                L.noLowering(`the ${ctorName} option 'signal'`, prop, "AbortSignal-driven destruction is not lowered yet");
+                lowerer.noLowering(`the ${ctorName} option 'signal'`, prop, "AbortSignal-driven destruction is not lowered yet");
                 break;
             case "captureRejections": {
                 // `false` is the default — admit the literal; the rejection-
@@ -566,7 +565,7 @@ fallbackCb) {
                 // abandoned unobserved).
                 if (value.kind === ts.SyntaxKind.FalseKeyword)
                     break;
-                L.noLowering(`the ${ctorName} option 'captureRejections'`, prop, "captureRejections has no lowering (listener rejections are not routed to 'error')");
+                lowerer.noLowering(`the ${ctorName} option 'captureRejections'`, prop, "captureRejections has no lowering (listener rejections are not routed to 'error')");
                 break;
             }
             case "readable":
@@ -574,7 +573,7 @@ fallbackCb) {
                 // Duplex side toggles: compile-time literals only (they decide
                 // which halves EXIST).
                 if (ctorName !== "Duplex") {
-                    L.noLowering(`the ${ctorName} option '${name}'`, prop);
+                    lowerer.noLowering(`the ${ctorName} option '${name}'`, prop);
                 }
                 if (value.kind === ts.SyntaxKind.TrueKeyword)
                     break;
@@ -585,23 +584,23 @@ fallbackCb) {
                         out.writableSide = false;
                     break;
                 }
-                L.noLowering(`the Duplex option '${name}' with a non-literal value`, prop, "the side toggles must be compile-time booleans");
+                lowerer.noLowering(`the Duplex option '${name}' with a non-literal value`, prop, "the side toggles must be compile-time booleans");
                 break;
             }
             case "final": {
-                L.noLowering(`the ${ctorName} option 'final'`, prop, ctorName === "Transform"
+                lowerer.noLowering(`the ${ctorName} option 'final'`, prop, ctorName === "Transform"
                     ? "a user final on a Transform replaces the _flush composition — no lowering yet"
                     : "the final callback is supported on Writable and Duplex");
                 break;
             }
             case "construct":
-                L.noLowering(`the ${ctorName} option 'construct'`, prop, "deferred construction (_construct) is not lowered yet");
+                lowerer.noLowering(`the ${ctorName} option 'construct'`, prop, "deferred construction (_construct) is not lowered yet");
                 break;
             case "writev":
-                L.noLowering(`the ${ctorName} option 'writev'`, prop, "batched writes (_writev) are not lowered yet — writes deliver one chunk at a time");
+                lowerer.noLowering(`the ${ctorName} option 'writev'`, prop, "batched writes (_writev) are not lowered yet — writes deliver one chunk at a time");
                 break;
             default:
-                L.noLowering(`the ${ctorName} option '${name}'`, prop);
+                lowerer.noLowering(`the ${ctorName} option '${name}'`, prop);
         }
     }
     // Canonical flag order = the accepted list's order. Options win over
@@ -619,35 +618,35 @@ fallbackCb) {
 /** The head + flags argument list of a stream construction/initialization
  * (shared by `new Readable({...})` and a subclass's super(options)),
  * plus the parsed `encoding` option (applied as a follow-up setEncoding). */
-function streamCtorArgs(L, cls, arg, thisType, loc, fallbackCb) {
+function streamCtorArgs(lowerer, cls, arg, thisType, loc, fallbackCb) {
     const shape = streamCtorShape(cls);
-    const o = parseStreamOptions(L, cls.slice(1), arg, thisType, shape.accepted, loc, fallbackCb);
+    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), f64Lit(o.flags, loc)]
-        : [cls === "%Writable" ? o.hwmW : o.hwmR, o.autoDestroy, o.emitClose, f64Lit(o.flags, loc)];
+            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 };
 }
 /** `new Readable(opts?)` and friends — called from lowerNew once the
  * callee resolved to a builtin stream class. */
-export function lowerStreamNew(L, expr, info) {
+export function lowerStreamNew(lowerer, expr, info) {
     const loc = locOf(expr);
     const cls = info.def.name;
     if (!RUNTIME_STREAM_CLASSES.has(cls))
-        L.unsupported("SC1090", expr, `constructing ${cls}`);
+        lowerer.unsupported("SC1090", expr, `constructing ${cls}`);
     const thisType = { kind: "object", className: cls };
     const args = expr.arguments ?? [];
     if (args.length > 1) {
-        L.noLowering(`new ${info.def.name.slice(1)} with ${args.length} arguments`, expr, "the supported form takes one options object");
+        lowerer.noLowering(`new ${info.def.name.slice(1)} with ${args.length} arguments`, expr, "the supported form takes one options object");
     }
     if (args[0] !== undefined) {
-        const dynOpts = dynOptionsValue(L, args[0]);
+        const dynOpts = dynOptionsValue(lowerer, args[0]);
         if (dynOpts !== null) {
             return { kind: "libCall", fn: `${streamCtorShape(cls).fn}.newDyn`, args: [dynOpts], type: thisType, loc };
         }
     }
     const fn = `${streamCtorShape(cls).fn}.new`;
-    const parsed = streamCtorArgs(L, cls, args[0], thisType, loc);
+    const parsed = streamCtorArgs(lowerer, cls, args[0], thisType, loc);
     if (parsed.badEncoding !== null) {
         // Node's state constructors validate encodings first: an unknown
         // spelling never constructs — the whole expression throws.
@@ -672,14 +671,14 @@ export function lowerStreamNew(L, expr, info) {
  * overrides it (the ordinary devirtualization rule), so an inherited
  * constructor still binds the DYNAMIC class's override. The method may
  * declare any PREFIX of its Node signature (the option-callback rule). */
-function streamMethodWrapper(L, info, which, methodName, thisType, loc, blame) {
-    const found = L.findMethodOn(info, methodName);
+function streamMethodWrapper(lowerer, info, which, methodName, thisType, loc, blame) {
+    const found = lowerer.findMethodOn(info, methodName);
     if (!found) {
         // A DESCENDANT-only declaration (the base chain never declares it):
         // this constructor cannot see it, and silently binding nothing would
         // diverge from Node (which dispatches through the prototype chain).
-        if (L.overrideBelow(info, methodName)) {
-            L.noLowering(`a subclass of ${info.def.name.replace(/^%/, "")} declaring '${methodName}' below a base whose constructor cannot see it`, blame, `declare '${methodName}' on the class whose constructor calls the stream super(), and override it below`);
+        if (lowerer.overrideBelow(info, methodName)) {
+            lowerer.noLowering(`a subclass of ${info.def.name.replace(/^%/, "")} declaring '${methodName}' below a base whose constructor cannot see it`, blame, `declare '${methodName}' on the class whose constructor calls the stream super(), and override it below`);
         }
         return null;
     }
@@ -688,22 +687,22 @@ function streamMethodWrapper(L, info, which, methodName, thisType, loc, blame) {
     // class itself is abstract, so this constructor only ever runs under a
     // subclass — which, if concrete, implements the method and flips
     // overrideBelow into the virtual branch below).
-    if (found.sig.abstract === true && !L.overrideBelow(info, methodName)) {
-        L.noLowering(`an abstract '${methodName}' declaration with no concrete implementation below ${info.def.name.replace(/^%/, "")}`, blame, `implement '${methodName}' on a subclass the program constructs`);
+    if (found.sig.abstract === true && !lowerer.overrideBelow(info, methodName)) {
+        lowerer.noLowering(`an abstract '${methodName}' declaration with no concrete implementation below ${info.def.name.replace(/^%/, "")}`, blame, `implement '${methodName}' on a subclass the program constructs`);
         return null;
     }
-    const tuples = cbTuples(L);
+    const tuples = cbTuples(lowerer);
     const full = tuples[which];
     const declared = found.sig.params;
     if (declared.length > full.length) {
-        L.noLowering(`a '${methodName}' method declaring ${declared.length} parameters where Node passes ${full.length}`, blame, "stream underscore methods may declare a prefix of their Node signature");
+        lowerer.noLowering(`a '${methodName}' method declaring ${declared.length} parameters where Node passes ${full.length}`, blame, "stream underscore methods may declare a prefix of their Node signature");
     }
     const paramTypes = [];
     for (let i = 0; i < declared.length; i++) {
         const want = full[i];
         const got = declared[i];
         if (got.mode !== "required") {
-            L.noLowering(`a '${methodName}' method with optional or defaulted parameters`, blame, "declare the Node signature's parameters plainly (any prefix is fine)");
+            lowerer.noLowering(`a '${methodName}' method with optional or defaulted parameters`, blame, "declare the Node signature's parameters plainly (any prefix is fine)");
         }
         if (got.type.kind === "dyn") {
             // The JS lane's implicitly-any parameters: the emitted invoke
@@ -711,39 +710,39 @@ function streamMethodWrapper(L, info, which, methodName, thisType, loc, blame) {
         }
         else if (want === "fn") {
             if (got.type.kind !== "func") {
-                L.noLowering(`a '${methodName}' method whose parameter ${i} is '${L.fmt(got.type)}' where Node passes the completion callback`, blame);
+                lowerer.noLowering(`a '${methodName}' method whose parameter ${i} is '${lowerer.fmt(got.type)}' where Node passes the completion callback`, blame);
             }
         }
         else if (!typeEquals(got.type, want)) {
-            L.noLowering(`a '${methodName}' method whose parameter ${i} is '${L.fmt(got.type)}' where Node passes '${L.fmt(want)}'`, blame, "annotate the parameter with the Node signature's type (chunks are Buffers here)");
+            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)");
         }
         paramTypes.push(got.type);
     }
     const ret = found.sig.ret;
-    const fnName = `%fn${L.lambdaCounter++}_${which}vt`;
+    const fnName = `%fn${lowerer.lambdaCounter++}_${which}vt`;
     const funcType = funcOf([thisType, ...paramTypes], ret);
-    L.fnStack.push(newFnCtx(true, null, funcType, ret));
+    lowerer.fnStack.push(newFnCtx(true, null, funcType, ret));
     try {
-        const thisLocal = L.declareThis(thisType);
+        const thisLocal = lowerer.declareThis(thisType);
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
         const argRefs = [];
         for (let i = 0; i < paramTypes.length; i++) {
-            const local = L.declareHiddenLocal(`a${i}`, paramTypes[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 thisRef = { kind: "varRef", localId: thisLocal.id, type: thisType, loc };
         let call;
-        if (L.overrideBelow(info, methodName)) {
-            L.noteVirtualEdge(info, methodName);
+        if (lowerer.overrideBelow(info, methodName)) {
+            lowerer.noteVirtualEdge(info, methodName);
             call = { kind: "virtualCall", className: info.def.name, method: methodName, args: [thisRef, ...argRefs], type: ret, loc };
         }
         else {
-            L.noteEdge(`%${found.declarer.def.name}.${methodName}`);
+            lowerer.noteEdge(`%${found.declarer.def.name}.${methodName}`);
             call = {
                 kind: "call",
                 callee: `%${found.declarer.def.name}.${methodName}`,
-                args: [L.upcastTo(thisRef, found.declarer.def.name), ...argRefs],
+                args: [lowerer.upcastTo(thisRef, found.declarer.def.name), ...argRefs],
                 type: ret,
                 loc,
             };
@@ -751,9 +750,9 @@ function streamMethodWrapper(L, info, which, methodName, thisType, loc, blame) {
         const body = ret.kind === "void"
             ? [{ kind: "exprStmt", expr: call, loc }]
             : [{ kind: "return", value: call, loc }];
-        appendImplicitUndefinedReturn(L, body, ret, loc);
-        const ctx = L.ctx;
-        L.liftedFns.push({
+        appendImplicitUndefinedReturn(lowerer, body, ret, loc);
+        const ctx = lowerer.ctx;
+        lowerer.liftedFns.push({
             name: fnName,
             params,
             returnType: ret,
@@ -765,7 +764,7 @@ function streamMethodWrapper(L, info, which, methodName, thisType, loc, blame) {
         return { kind: "closure", fnName, captures: ctx.captureSources, type: funcType, loc };
     }
     finally {
-        L.fnStack.pop();
+        lowerer.fnStack.pop();
     }
 }
 /** `super(options?)` in a class whose direct base chain lands on a
@@ -774,20 +773,20 @@ function streamMethodWrapper(L, info, which, methodName, thisType, loc, blame) {
  * display name; the runtime builds the state block). Options parse
  * exactly like the construction form; overridden underscore methods on
  * the class chain fill callbacks the options leave unset. */
-export function lowerStreamSuperCall(L, info, base, argNodes, thisLocal, loc, blame) {
+export function lowerStreamSuperCall(lowerer, info, base, argNodes, thisLocal, loc, blame) {
     const cls = base.def.name;
     const thisType = { kind: "object", className: info.def.name };
     if (argNodes.length > 1) {
-        L.noLowering(`super(...) with ${argNodes.length} arguments in a ${cls.slice(1)} subclass`, blame, "the supported form takes one inline options object (or none)");
+        lowerer.noLowering(`super(...) with ${argNodes.length} arguments in a ${cls.slice(1)} subclass`, blame, "the supported form takes one inline options object (or none)");
     }
     const shape = streamCtorShape(cls);
     const fallback = (name) => {
         const methodName = UNDERSCORE_METHODS.get(name);
-        return methodName ? streamMethodWrapper(L, 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) {
-        const dynOpts = dynOptionsValue(L, argNodes[0]);
+        const dynOpts = dynOptionsValue(lowerer, argNodes[0]);
         if (dynOpts !== null) {
             // The dyn-options twin: the runtime walks the record; the class's
             // overridden underscore methods ride as FALLBACK wrappers (an
@@ -806,7 +805,7 @@ export function lowerStreamSuperCall(L, info, base, argNodes, thisLocal, loc, bl
                     expr: {
                         kind: "libCall",
                         fn: `${shape.fn}.initDyn`,
-                        args: [thisRef(), dynOpts, f64Lit(flags, loc), ...cbs],
+                        args: [thisRef(), dynOpts, numLit(flags, loc), ...cbs],
                         type: VOID,
                         loc,
                     },
@@ -814,7 +813,7 @@ export function lowerStreamSuperCall(L, info, base, argNodes, thisLocal, loc, bl
                 }];
         }
     }
-    const parsed = streamCtorArgs(L, cls, argNodes[0], thisType, loc, fallback);
+    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.
@@ -859,7 +858,7 @@ export function lowerStreamSuperCall(L, info, base, argNodes, thisLocal, loc, bl
  * runtime-stream-rooted receiver (the caller's routes continue);
  * `_writev` and methods outside the receiver's base set keep pointed
  * fences (Node would consume them through unlowered machinery). */
-export function lowerStreamUnderscoreAssign(L, expr) {
+export function lowerStreamUnderscoreAssign(lowerer, expr) {
     if (!ts.isPropertyAccessExpression(expr.left) || expr.left.questionDotToken)
         return null;
     const methodName = expr.left.name.text;
@@ -868,10 +867,10 @@ export function lowerStreamUnderscoreAssign(L, expr) {
     const optionByMethod = new Map(Array.from(UNDERSCORE_METHODS, ([o, m]) => [m, o]));
     if (!optionByMethod.has(methodName) && methodName !== "_writev" && methodName !== "_construct")
         return null;
-    const recv = probeLower(L, expr.left.expression);
+    const recv = probeLower(lowerer, expr.left.expression);
     if (!recv || recv.type.kind !== "object")
         return null;
-    const info = L.classes.get(recv.type.className);
+    const info = lowerer.classes.get(recv.type.className);
     let base = null;
     for (let c = info ?? null; c; c = c.base) {
         if (RUNTIME_STREAM_CLASSES.has(c.def.name)) {
@@ -885,35 +884,35 @@ export function lowerStreamUnderscoreAssign(L, expr) {
     const cls = base.def.name;
     const clsName = cls.slice(1);
     if (methodName === "_writev" || methodName === "_construct") {
-        L.noLowering(`assigning '${methodName}' on a ${clsName}`, expr.left, methodName === "_writev"
+        lowerer.noLowering(`assigning '${methodName}' on a ${clsName}`, expr.left, methodName === "_writev"
             ? "batched writes (_writev) are not lowered yet — writes deliver one chunk at a time"
             : "deferred construction (_construct) is not lowered yet");
     }
     const which = optionByMethod.get(methodName);
     const { accepted } = streamCtorShape(cls);
     if (!accepted.includes(which)) {
-        L.noLowering(`assigning '${methodName}' on a ${clsName}`, expr.left, `a ${clsName}'s machinery consumes ${accepted.map((a) => `'${UNDERSCORE_METHODS.get(a)}'`).join("/")} — '${methodName}' would ride machinery with no lowering here`);
+        lowerer.noLowering(`assigning '${methodName}' on a ${clsName}`, expr.left, `a ${clsName}'s machinery consumes ${accepted.map((a) => `'${UNDERSCORE_METHODS.get(a)}'`).join("/")} — '${methodName}' would ride machinery with no lowering here`);
     }
     const thisType = recv.type;
-    const tuples = cbTuples(L);
+    const tuples = cbTuples(lowerer);
     let cb;
     const rhs = expr.right;
     if (ts.isFunctionExpression(rhs) || ts.isArrowFunction(rhs)) {
         const full = tuples[which].map((t) => (t === "fn" ? null : t));
-        const { funcType } = L.lambdaSignature(rhs);
+        const { funcType } = lowerer.lambdaSignature(rhs);
         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") {
-                L.noLowering(`a '${methodName}' callback whose parameter ${i} is '${L.fmt(declared)}' where Node passes the completion callback`, rhs);
+                lowerer.noLowering(`a '${methodName}' callback whose parameter ${i} is '${lowerer.fmt(declared)}' where Node passes the completion callback`, rhs);
             }
             return declared ?? funcOf([], VOID);
         });
-        cb = lowerStreamCallback(L, which, rhs, thisType, tuple);
+        cb = lowerStreamCallback(lowerer, which, rhs, thisType, tuple);
     }
     else {
-        cb = lowerStreamCallbackValue(L, clsName, which, rhs, tuples[which].length);
+        cb = lowerStreamCallbackValue(lowerer, clsName, which, rhs, tuples[which].length);
     }
     const SET_FNS = {
         read: "stream.setRead",
@@ -936,22 +935,22 @@ export function lowerStreamUnderscoreAssign(L, expr) {
  * accounting; hwm 1), and a single string/Buffer argument is a
  * one-chunk stream (Node's special case). Called from the method-call
  * chain once the receiver resolved to a stream class value. */
-export function lowerStreamStaticCall(L, call, access) {
+export function lowerStreamStaticCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
     let symbol = null;
     if (ts.isIdentifier(access.expression)) {
-        symbol = L.resolveValueSymbol(access.expression);
+        symbol = lowerer.resolveValueSymbol(access.expression);
     }
     else if (ts.isPropertyAccessExpression(access.expression) && ts.isIdentifier(access.expression.name)) {
-        const memberSym = L.checker.getSymbolAtLocation(access.expression.name);
+        const memberSym = lowerer.checker.getSymbolAtLocation(access.expression.name);
         symbol = memberSym && memberSym.flags & ts.SymbolFlags.Alias
-            ? L.checker.getAliasedSymbol(memberSym)
+            ? lowerer.checker.getAliasedSymbol(memberSym)
             : memberSym;
     }
     if (!symbol)
         return null;
-    const info = L.builtinStreamInfoOf(symbol);
+    const info = lowerer.builtinStreamInfoOf(symbol);
     if (!info)
         return null;
     const member = access.name.text;
@@ -964,39 +963,39 @@ export function lowerStreamStaticCall(L, call, access) {
         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 = L.typeOf(p.initializer);
+                const t = lowerer.typeOf(p.initializer);
                 if (t.isStringLiteralType() && t.value !== "bytes") {
-                    L.lowerExpr(call.arguments[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}'`, L.mapTypeOf(L.typeOf(call)) ?? DYN, loc);
+                    lowerer.lowerExpr(call.arguments[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);
                 }
             }
         }
     }
     if (member !== "from") {
-        L.noLowering(`${cls.slice(1)}.${member}`, call);
+        lowerer.noLowering(`${cls.slice(1)}.${member}`, call);
     }
     if (cls !== "%Readable") {
-        L.noLowering(`${cls.slice(1)}.from`, call, "Readable.from is the lowered form");
+        lowerer.noLowering(`${cls.slice(1)}.from`, call, "Readable.from is the lowered form");
     }
     const args = call.arguments;
     if (args.length !== 1) {
-        L.noLowering(`Readable.from with ${args.length} arguments`, call, "the one-argument form (an array, string, or Buffer) is supported");
+        lowerer.noLowering(`Readable.from with ${args.length} arguments`, call, "the one-argument form (an array, string, or Buffer) is supported");
     }
-    const srcT = L.mapTypeOf(L.typeOf(args[0]));
+    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"))) {
-        const arr = L.lowerExpr(args[0]);
+        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 };
     }
     if (srcT?.kind === "string" || (srcT?.kind === "bytes" && srcT.elem === "u8")) {
         // Node special-cases a single string/Buffer: ONE whole chunk.
-        const v = L.lowerExpr(args[0]);
+        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 };
     }
-    L.noLowering(`Readable.from over a '${srcT ? L.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");
+    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");
 }
 /** `const Writable = stream.Writable` — a runtime stream CLASS bound
  * through a namespace member: alias plumbing with no storage (both
@@ -1004,7 +1003,7 @@ export function lowerStreamStaticCall(L, call, access) {
  * alias following). Only the five stream class names count — value
  * members (stream.getDefaultHighWaterMark as a value, ...) keep their
  * per-site fences. */
-export function streamClassAliasDecl(L, nameNode, init) {
+export function streamClassAliasDecl(lowerer, nameNode, init) {
     if (!ts.isIdentifier(nameNode) || !init)
         return false;
     if (!ts.isPropertyAccessExpression(init) || init.questionDotToken)
@@ -1016,7 +1015,7 @@ export function streamClassAliasDecl(L, nameNode, init) {
     }
     if (!isStreamClass)
         return false;
-    return L.builtinNamespaceModuleOf(init.expression) === "stream";
+    return lowerer.builtinNamespaceModuleOf(init.expression) === "stream";
 }
 /* ── the module functions (finished / pipeline — the callback forms) ──── */
 /** Node's pipeline stage ladder text (lib/internal/streams/pipeline.js's
@@ -1029,10 +1028,10 @@ const PIPELINE_STAGE_EXPECTED = "of type function or an instance of Blob, Readab
  * isNodeStream, while pipeline() accepts iterables (strings, arrays) and
  * { readable, writable } pairs — those shapes fence instead of throwing
  * a ladder Node never throws. */
-function lowerStreamArg(L, node, what) {
-    const v = L.lowerExpr(node);
-    const info = v.type.kind === "object" ? L.classes.get(v.type.className) : undefined;
-    if (!streamSidesOf(L, info)) {
+function lowerStreamArg(lowerer, node, what) {
+    const v = lowerer.lowerExpr(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
         // probes: finished({}, cb), pipeline(42, dst, cb)): Node's gate
         // throws ERR_INVALID_ARG_TYPE before any watcher exists.
@@ -1049,14 +1048,14 @@ function lowerStreamArg(L, node, what) {
                 loc: locOf(node),
             });
         };
-        if (isJsSourceFile(node.getSourceFile()) && L.dynConvertible(v.type)) {
+        if (isJsSourceFile(node.getSourceFile()) && 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
                 // the duplex-pair form; none of those shapes has a lowering, so
                 // they take the pointed fence below, never a throw.
                 const pairish = v.type.kind === "record" &&
-                    (L.shapes.get(v.type.shapeId)?.fields ?? []).some((f) => f.name === "readable" || f.name === "writable");
+                    (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") {
                     argTypeThrow("body", PIPELINE_STAGE_EXPECTED);
@@ -1067,7 +1066,7 @@ function lowerStreamArg(L, node, what) {
                 argTypeThrow("stream", "an instance of ReadableStream, WritableStream, or Stream");
             }
         }
-        L.noLowering(`${what} over a '${L.fmt(v.type)}'`, node, what === "pipeline"
+        lowerer.noLowering(`${what} over a '${lowerer.fmt(v.type)}'`, node, what === "pipeline"
             ? "stream stages are the lowered surface — Node also accepts iterables (strings, arrays), generators, plain functions, and { readable, writable } pairs, but those have no lowering yet"
             : "stream arguments are the lowered surface (iterables, generators, and plain functions have no lowering yet)");
     }
@@ -1090,17 +1089,17 @@ class StreamArgTypeThrow {
  * value adapts through the checked-dynamic boundary (mustCall wrappers —
  * the runtime inv calls it with NO arguments on success, Node's eos
  * convention). */
-function lowerEosCallback(L, which, node, thisType) {
+function lowerEosCallback(lowerer, which, node, thisType) {
     if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
         // The error parameter takes what the user declared when it is an
         // Error/null/undefined union (@types spells `ErrnoException | null |
         // undefined`); the emitted thunk picks the undefined arm on success.
-        let tuple = [errorOrNull(L)];
+        let tuple = [errorOrNull(lowerer)];
         try {
-            const { funcType } = L.lambdaSignature(node);
+            const { funcType } = lowerer.lambdaSignature(node);
             const p0 = funcType.params[0];
             if (p0?.kind === "union") {
-                const def = L.unions.get(p0.unionId);
+                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" ||
                         (a.kind === "object" && a.className === "%Error"))) {
@@ -1111,36 +1110,36 @@ function lowerEosCallback(L, which, node, thisType) {
         catch {
             /* the fixed tuple speaks */
         }
-        return { cb: lowerStreamCallback(L, which, node, thisType, tuple), dyn: false };
+        return { cb: lowerStreamCallback(lowerer, which, node, thisType, tuple), dyn: false };
     }
-    const getRecord = (id) => L.shapes.get(id);
-    const getUnion = (id) => L.unions.get(id);
+    const getRecord = (id) => lowerer.shapes.get(id);
+    const getUnion = (id) => lowerer.unions.get(id);
     let t;
     try {
-        const ct = L.typeOf(node);
-        t = L.mapTypeOf(ct) ?? dynFallbackType(L, node, ct);
+        const ct = lowerer.typeOf(node);
+        t = lowerer.mapTypeOf(ct) ?? dynFallbackType(lowerer, node, ct);
     }
     catch {
         t = null;
     }
     if (t?.kind === "dyn") {
-        const v = L.lowerExpr(node);
+        const v = lowerer.lowerExpr(node);
         if (v.type.kind === "dyn")
             return { cb: v, dyn: true };
     }
     else if (t?.kind === "func") {
-        const cb = L.lowerExpr(node);
+        const cb = lowerer.lowerExpr(node);
         if (cb.type.kind === "func" && canBoxFuncIntoDyn(cb.type, getRecord, getUnion)) {
             return { cb: { kind: "dynFrom", value: cb, type: DYN, loc: locOf(node) }, dyn: true };
         }
     }
-    L.noLowering(`${which} with this callback value`, node, "write the callback inline, or pass a function value that crosses the checked-dynamic boundary");
+    lowerer.noLowering(`${which} with this callback value`, node, "write the callback inline, or pass a function value that crosses the checked-dynamic boundary");
 }
 /** `finished(...)` / `pipeline(...)` / `getDefaultHighWaterMark(...)`
  * imported from node:stream (named imports, destructured requires, and
  * namespace-member calls all land here). Null for members this spoke
  * does not own — the caller's module-qualified fence speaks. */
-export function lowerStreamModuleCall(L, call, bi, loc) {
+export function lowerStreamModuleCall(lowerer, call, bi, loc) {
     if (bi.module === "stream/promises") {
         const args = call.arguments;
         // finished(stream) → a pending void promise the terminal watcher
@@ -1149,11 +1148,11 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
         // through the promise instead). The options argument has no lowering.
         if (bi.member === "finished") {
             if (args.length !== 1) {
-                L.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 {
-                recv = lowerStreamArg(L, args[0], "finished");
+                recv = lowerStreamArg(lowerer, args[0], "finished");
             }
             catch (e) {
                 if (e instanceof StreamArgTypeThrow)
@@ -1168,11 +1167,11 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
         // stream destinations, so the result is a void promise.
         if (bi.member === "pipeline") {
             if (args.length < 2) {
-                L.noLowering(`stream/promises.pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams)");
+                lowerer.noLowering(`stream/promises.pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams)");
             }
             let streams;
             try {
-                streams = args.map((a) => lowerStreamArg(L, a, "pipeline"));
+                streams = args.map((a) => lowerStreamArg(lowerer, a, "pipeline"));
             }
             catch (e) {
                 if (e instanceof StreamArgTypeThrow)
@@ -1182,7 +1181,7 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
             return {
                 kind: "libCall",
                 fn: "sp.pipeline",
-                args: [f64Lit(streams.length, loc), ...streams],
+                args: [numLit(streams.length, loc), ...streams],
                 type: { kind: "promise", inner: VOID },
                 loc,
             };
@@ -1201,7 +1200,7 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
         // hints in BUILTIN_MODULE_FENCE_HINTS) speaks.
         if (bi.member === "text" || bi.member === "json" || bi.member === "buffer") {
             if (args.length !== 1) {
-                L.noLowering(`stream/consumers.${bi.member} with ${args.length} arguments`, call, `the supported form is ${bi.member}(stream)`);
+                lowerer.noLowering(`stream/consumers.${bi.member} with ${args.length} arguments`, call, `the supported form is ${bi.member}(stream)`);
             }
             // A provably-non-stream argument: Node's consumers reject the
             // returned promise asynchronously with the plain "stream is not
@@ -1209,10 +1208,10 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
             // (finished/pipeline throw synchronously; consumers do not). A
             // sync throw here would be observably wrong timing, so the
             // provable case takes the named fence instead.
-            const argV = L.lowerExpr(args[0]);
-            const argInfo = argV.type.kind === "object" ? L.classes.get(argV.type.className) : undefined;
-            if (argV.type.kind !== "dyn" && argV.type.kind !== "jsval" && !streamSidesOf(L, argInfo)) {
-                L.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 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)) {
+                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;
             const inner = bi.member === "text" ? STRING : bi.member === "json" ? DYN : BYTES;
@@ -1235,26 +1234,26 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
         // (lib/internal/streams/state.js: win32 keeps 16 KiB), so the fold
         // follows the TARGET platform like the path-module binding.
         if (args.length === 1 && args[0].kind === ts.SyntaxKind.FalseKeyword) {
-            return f64Lit(L.targetPlatform === "win32" ? 16384 : 65536, loc);
+            return numLit(lowerer.targetPlatform === "win32" ? 16384 : 65536, loc);
         }
         if (args.length === 1 && args[0].kind === ts.SyntaxKind.TrueKeyword)
-            return f64Lit(16, loc);
-        L.noLowering("getDefaultHighWaterMark with a non-literal argument", call, "the objectMode flag must be a compile-time boolean");
+            return numLit(16, loc);
+        lowerer.noLowering("getDefaultHighWaterMark with a non-literal argument", call, "the objectMode flag must be a compile-time boolean");
     }
     if (bi.member === "finished") {
         if (args.length !== 2) {
-            L.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 {
-            recv = lowerStreamArg(L, args[0], "finished");
+            recv = lowerStreamArg(lowerer, args[0], "finished");
         }
         catch (e) {
             if (e instanceof StreamArgTypeThrow)
                 return e.expr;
             throw e;
         }
-        const { cb, dyn } = lowerEosCallback(L, "finished", args[1], recv.type);
+        const { cb, dyn } = lowerEosCallback(lowerer, "finished", args[1], recv.type);
         return {
             kind: "libCall",
             fn: dyn ? "stream.finishedDyn" : "stream.finished",
@@ -1265,11 +1264,11 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
     }
     if (bi.member === "pipeline") {
         if (args.length < 3) {
-            L.noLowering(`pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams, callback)");
+            lowerer.noLowering(`pipeline with ${args.length} arguments`, call, "the supported form is pipeline(source, ...streams, callback)");
         }
         let streams;
         try {
-            streams = args.slice(0, -1).map((a) => lowerStreamArg(L, a, "pipeline"));
+            streams = args.slice(0, -1).map((a) => lowerStreamArg(lowerer, a, "pipeline"));
         }
         catch (e) {
             if (e instanceof StreamArgTypeThrow)
@@ -1277,11 +1276,11 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
             throw e;
         }
         const last = streams[streams.length - 1];
-        const { cb, dyn } = lowerEosCallback(L, "pipeline", args[args.length - 1], last.type);
+        const { cb, dyn } = lowerEosCallback(lowerer, "pipeline", args[args.length - 1], last.type);
         return {
             kind: "libCall",
             fn: dyn ? "stream.pipelineDyn" : "stream.pipeline",
-            args: [f64Lit(streams.length, loc), ...streams, cb],
+            args: [numLit(streams.length, loc), ...streams, cb],
             type: last.type,
             loc,
         };
@@ -1291,21 +1290,21 @@ export function lowerStreamModuleCall(L, call, bi, loc) {
 /* ── the method surface ───────────────────────────────────────────────── */
 /** The one supported encoding argument: utf8 (Node's default), as a
  * compile-time literal or absent. */
-function checkUtf8Encoding(L, member, arg) {
+function checkUtf8Encoding(lowerer, member, arg) {
     if (arg === undefined)
         return;
-    const t = L.typeOf(arg);
+    const t = lowerer.typeOf(arg);
     if (t.isStringLiteralType() && (t.value === "utf8" || t.value === "utf-8"))
         return;
-    L.noLowering(`${member} with a ${t.isStringLiteralType() ? `'${t.value}'` : "non-literal"} encoding`, arg, "utf8 (as a compile-time literal) is the supported encoding");
+    lowerer.noLowering(`${member} with a ${t.isStringLiteralType() ? `'${t.value}'` : "non-literal"} encoding`, arg, "utf8 (as a compile-time literal) is the supported encoding");
 }
 /** `recv.<member>(...)` over a stream-rooted receiver. Returns null only
  * for members this spoke does not own. */
-export function lowerStreamMethodCall(L, call, access, info) {
+export function lowerStreamMethodCall(lowerer, call, access, info) {
     const member = access.name.text;
     if (!STREAM_API_MEMBERS.has(member))
         return null;
-    const sides = streamSidesOf(L, info);
+    const sides = streamSidesOf(lowerer, info);
     if (!sides)
         return null;
     const loc = locOf(call);
@@ -1315,7 +1314,7 @@ export function lowerStreamMethodCall(L, call, access, info) {
     const cls = info.def.name.slice(1);
     const requireSide = (need, what) => {
         if (!need) {
-            L.noLowering(`${what} on a ${cls} (the ${what.startsWith("write") || what === "end" || what === "cork" || what === "uncork" ? "writable" : "readable"} half is absent)`, call);
+            lowerer.noLowering(`${what} on a ${cls} (the ${what.startsWith("write") || what === "end" || what === "cork" || what === "uncork" ? "writable" : "readable"} half is absent)`, call);
         }
     };
     // Chunk classification for push/unshift/write/end. Union-typed chunks
@@ -1324,7 +1323,7 @@ export function lowerStreamMethodCall(L, call, access, info) {
     const chunkKind = (node) => {
         if (node.kind === ts.SyntaxKind.NullKeyword)
             return "null";
-        const t = L.mapTypeOf(L.typeOf(node));
+        const t = lowerer.mapTypeOf(lowerer.typeOf(node));
         if (t?.kind === "bytes" && t.elem === "u8")
             return "bytes";
         if (t?.kind === "string")
@@ -1337,7 +1336,7 @@ export function lowerStreamMethodCall(L, call, access, info) {
             return "dyn";
         }
         if (t?.kind === "union") {
-            const def = L.unions.get(t.unionId);
+            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")) {
                 return "union";
             }
@@ -1346,7 +1345,7 @@ export function lowerStreamMethodCall(L, call, access, info) {
             // A checker-untyped chunk (the JS lane's `t.write(x.toString())`
             // shapes): the LOWERING may still land on a supported kind — probe
             // it (the probe's IR is discarded; the caller re-lowers the node).
-            const probed = probeLower(L, node);
+            const probed = probeLower(lowerer, node);
             if (probed?.type.kind === "string")
                 return "string";
             if (probed?.type.kind === "bytes" && probed.type.elem === "u8")
@@ -1356,12 +1355,12 @@ export function lowerStreamMethodCall(L, call, access, info) {
             if (probed?.type.kind === "nullT")
                 return "null";
         }
-        L.noLowering(`${member} with a '${t ? L.fmt(t) : "?"}' chunk`, node, "chunks are Buffers or utf8 strings — or unions of those with null (objectMode is not lowered)");
+        lowerer.noLowering(`${member} with a '${t ? lowerer.fmt(t) : "?"}' chunk`, node, "chunks are Buffers or utf8 strings — or unions of those with null (objectMode is not lowered)");
     };
     if (member === "push" || member === "unshift") {
         requireSide(readableSide, member);
         if (args.length === 0 || args.length > 2) {
-            L.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)
@@ -1369,14 +1368,14 @@ export function lowerStreamMethodCall(L, call, access, info) {
         // Node's ERR_UNKNOWN_ENCODING when the push evaluates. unshift keeps
         // the utf8-only fence below.
         if (member === "push" && args[1] !== undefined && chunkKind(args[0]) === "string") {
-            const t = L.typeOf(args[1]);
+            const t = lowerer.typeOf(args[1]);
             if (t.isStringLiteralType()) {
                 const canonical = knownBufEncoding(t.value);
                 if (canonical === undefined) {
                     return nodeThrowExpr(1, "ERR_UNKNOWN_ENCODING", `Unknown encoding: ${t.value}`, BOOL, loc);
                 }
-                const receiver = L.lowerExpr(access.expression);
-                const chunk = L.lowerExprExpecting(args[0], STRING);
+                const receiver = lowerer.lowerExpr(access.expression);
+                const chunk = lowerer.lowerExprExpecting(args[0], STRING);
                 return {
                     kind: "libCall",
                     fn: "readable.pushStrEnc",
@@ -1386,23 +1385,23 @@ export function lowerStreamMethodCall(L, call, access, info) {
                 };
             }
         }
-        checkUtf8Encoding(L, member, args[1]);
+        checkUtf8Encoding(lowerer, member, args[1]);
         const kind = chunkKind(args[0]);
         if ((kind === "null" || kind === "union" || kind === "dyn") && member === "unshift") {
-            L.noLowering(kind === "null" ? "unshift(null)" : "unshift with a nullable or dynamic chunk", call, "EOF signals through push(null)");
+            lowerer.noLowering(kind === "null" ? "unshift(null)" : "unshift with a nullable or dynamic chunk", call, "EOF signals through push(null)");
         }
-        const receiver = L.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExpr(access.expression);
         if (kind === "null") {
             return { kind: "libCall", fn: "readable.pushNull", args: [receiver], type: BOOL, loc };
         }
         if (kind === "dyn") {
-            const chunk = L.lowerExprExpecting(args[0], DYN);
+            const chunk = lowerer.lowerExprExpecting(args[0], DYN);
             return { kind: "libCall", fn: "readable.pushDyn", args: [receiver, chunk], type: BOOL, loc };
         }
         if (kind === "union") {
             // The lowered value may have collapsed to one arm (checker
             // narrowing) — re-dispatch on its IR type.
-            const chunk = L.lowerExpr(args[0]);
+            const chunk = lowerer.lowerExpr(args[0]);
             if (chunk.type.kind === "union") {
                 return { kind: "libCall", fn: "readable.pushU", args: [receiver, chunk], type: BOOL, loc };
             }
@@ -1414,7 +1413,7 @@ export function lowerStreamMethodCall(L, call, access, info) {
             }
             return { kind: "libCall", fn: "readable.pushNull", args: [receiver], type: BOOL, loc };
         }
-        const chunk = kind === "bytes" ? L.lowerExprExpecting(args[0], BYTES) : L.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");
@@ -1423,64 +1422,64 @@ export function lowerStreamMethodCall(L, call, access, info) {
     if (member === "read") {
         requireSide(readableSide, "read");
         if (args.length > 1)
-            L.noLowering(`read with ${args.length} arguments`, call);
-        const receiver = L.lowerExpr(access.expression);
-        const size = args[0] ? L.lowerExprExpecting(args[0], F64) : f64Lit(-1, loc);
-        const type = unionOf(L, [BYTES, { kind: "nullT" }]);
+            lowerer.noLowering(`read with ${args.length} arguments`, call);
+        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 };
-        return L.maybeNarrow(read, call);
+        return lowerer.maybeNarrow(read, call);
     }
     if (member === "pause" || member === "resume") {
         requireSide(readableSide, member);
         if (args.length !== 0)
-            L.noLowering(`${member} with arguments`, call);
-        const receiver = L.lowerExpr(access.expression);
+            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 };
     }
     if (member === "isPaused") {
         requireSide(readableSide, "isPaused");
         if (args.length !== 0)
-            L.noLowering(`isPaused with arguments`, call);
-        const receiver = L.lowerExpr(access.expression);
+            lowerer.noLowering(`isPaused with arguments`, call);
+        const receiver = lowerer.lowerExpr(access.expression);
         return { kind: "libCall", fn: "readable.isPaused", args: [receiver], type: BOOL, loc };
     }
     if (member === "pipe") {
         requireSide(readableSide, "pipe");
         if (args.length === 0 || args.length > 2) {
-            L.noLowering(`pipe with ${args.length} arguments`, call, "the supported forms are (destination) and (destination, { end })");
+            lowerer.noLowering(`pipe with ${args.length} arguments`, call, "the supported forms are (destination) and (destination, { end })");
         }
-        const dst = L.lowerExpr(args[0]);
-        const dstInfo = dst.type.kind === "object" ? L.classes.get(dst.type.className) : undefined;
-        const dstSides = streamSidesOf(L, dstInfo);
+        const dst = lowerer.lowerExpr(args[0]);
+        const dstInfo = dst.type.kind === "object" ? lowerer.classes.get(dst.type.className) : undefined;
+        const dstSides = streamSidesOf(lowerer, dstInfo);
         if (dstSides !== "w" && dstSides !== "rw") {
-            L.noLowering(`pipe into a '${L.fmt(dst.type)}'`, args[0], "the destination must be a stream Writable/Duplex (process streams and sockets are not pipe destinations yet)");
+            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])) {
-                L.noLowering("pipe with a non-literal options argument", args[1], "{ end: <bool> } inline is the supported form");
+                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") {
-                    L.noLowering("a pipe option other than 'end'", prop);
+                    lowerer.noLowering("a pipe option other than 'end'", prop);
                 }
-                end = L.lowerExprExpecting(prop.initializer, BOOL);
+                end = lowerer.lowerExprExpecting(prop.initializer, BOOL);
             }
         }
-        const receiver = L.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExpr(access.expression);
         return { kind: "libCall", fn: "readable.pipe", args: [receiver, dst, end], type: dst.type, loc };
     }
     if (member === "unpipe") {
         requireSide(readableSide, "unpipe");
         if (args.length > 1)
-            L.noLowering(`unpipe with ${args.length} arguments`, call);
-        const receiver = L.lowerExpr(access.expression);
+            lowerer.noLowering(`unpipe with ${args.length} arguments`, call);
+        const receiver = lowerer.lowerExpr(access.expression);
         if (args[0] !== undefined) {
-            const dst = L.lowerExpr(args[0]);
-            const dstInfo = dst.type.kind === "object" ? L.classes.get(dst.type.className) : undefined;
-            const dstSides = streamSidesOf(L, dstInfo);
+            const dst = lowerer.lowerExpr(args[0]);
+            const dstInfo = dst.type.kind === "object" ? lowerer.classes.get(dst.type.className) : undefined;
+            const dstSides = streamSidesOf(lowerer, dstInfo);
             if (dstSides !== "w" && dstSides !== "rw") {
-                L.noLowering(`unpipe of a '${L.fmt(dst.type)}'`, args[0]);
+                lowerer.noLowering(`unpipe of a '${lowerer.fmt(dst.type)}'`, args[0]);
             }
             return { kind: "libCall", fn: "readable.unpipe", args: [receiver, dst], type: receiver.type, loc };
         }
@@ -1488,39 +1487,39 @@ export function lowerStreamMethodCall(L, call, access, info) {
     }
     if (member === "destroy") {
         if (args.length > 1)
-            L.noLowering(`destroy with ${args.length} arguments`, call);
-        const receiver = L.lowerExpr(access.expression);
+            lowerer.noLowering(`destroy with ${args.length} arguments`, call);
+        const receiver = lowerer.lowerExpr(access.expression);
         if (args[0] !== undefined) {
-            const err = L.lowerExpr(args[0]);
+            const err = lowerer.lowerExpr(args[0]);
             const rootsAtError = (t) => {
                 if (t.kind !== "object")
                     return false;
-                for (let c = L.classes.get(t.className) ?? null; c; c = c.base) {
+                for (let c = lowerer.classes.get(t.className) ?? null; c; c = c.base) {
                     if (c.def.name === "%Error")
                         return true;
                 }
                 return false;
             };
             if (!rootsAtError(err.type)) {
-                L.noLowering(`destroy with a '${L.fmt(err.type)}' argument`, args[0], "the supported argument is an Error-hierarchy instance");
+                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, L.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 };
     }
     if (member === "write") {
         requireSide(writableSide, "write");
         if (args.length === 0 || args.length > 3) {
-            L.noLowering(`write with ${args.length} arguments`, call);
+            lowerer.noLowering(`write with ${args.length} arguments`, call);
         }
         const kind = chunkKind(args[0]);
         if (kind === "null")
-            L.noLowering("write(null)", call, "end() finishes a writable");
+            lowerer.noLowering("write(null)", call, "end() finishes a writable");
         if (kind === "dyn") {
             if (args.length > 1)
-                L.noLowering("write with a dynamic chunk and more arguments", call);
-            const receiver = L.lowerExpr(access.expression);
-            const chunk = L.lowerExprExpecting(args[0], DYN);
+                lowerer.noLowering("write with a dynamic chunk and more arguments", call);
+            const receiver = lowerer.lowerExpr(access.expression);
+            const chunk = lowerer.lowerExprExpecting(args[0], DYN);
             return { kind: "libCall", fn: "writable.writeDyn", args: [receiver, chunk], type: BOOL, loc };
         }
         if (kind === "union") {
@@ -1529,36 +1528,36 @@ export function lowerStreamMethodCall(L, call, access, info) {
             // lowered value may have collapsed to one arm (checker narrowing) —
             // re-dispatch on its IR type.
             if (args.length > 1)
-                L.noLowering("write with a union chunk and more arguments", call);
-            const receiver = L.lowerExpr(access.expression);
-            const chunk = L.lowerExpr(args[0]);
+                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";
             if (chunk.type.kind === "nullT")
-                L.noLowering("write(null)", call, "end() finishes a writable");
+                lowerer.noLowering("write(null)", call, "end() finishes a writable");
             return { kind: "libCall", fn, args: [receiver, chunk], type: BOOL, loc };
         }
         // Disambiguate (chunk, cb?) vs (chunk, encoding, cb?) by the second
         // argument's static type.
         let cbArg;
         if (args.length === 2) {
-            const t = L.mapTypeOf(L.typeOf(args[1]));
+            const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
             if (t?.kind === "string")
-                checkUtf8Encoding(L, "write", args[1]);
+                checkUtf8Encoding(lowerer, "write", args[1]);
             else
                 cbArg = args[1];
         }
         else if (args.length === 3) {
-            checkUtf8Encoding(L, "write", args[1]);
+            checkUtf8Encoding(lowerer, "write", args[1]);
             cbArg = args[2];
         }
-        const receiver = L.lowerExpr(access.expression);
-        const chunk = kind === "bytes" ? L.lowerExprExpecting(args[0], BYTES) : L.lowerExprExpecting(args[0], STRING);
+        const receiver = lowerer.lowerExpr(access.expression);
+        const chunk = kind === "bytes" ? lowerer.lowerExprExpecting(args[0], BYTES) : lowerer.lowerExprExpecting(args[0], STRING);
         const fn = kind === "bytes" ? "writable.write" : "writable.writeStr";
         if (cbArg !== undefined) {
-            const cb = L.lowerExprExpecting(cbArg, funcOf([], VOID));
+            const cb = lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
             if (cb.type.kind !== "func" || cb.type.params.length > 0) {
-                L.noLowering("write completion callbacks taking the error argument", cbArg, "() => void callbacks are supported (listen for 'error' to observe failures)");
+                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 };
         }
@@ -1567,12 +1566,12 @@ export function lowerStreamMethodCall(L, call, access, info) {
     if (member === "end") {
         requireSide(writableSide, "end");
         if (args.length > 3)
-            L.noLowering(`end with ${args.length} arguments`, call);
+            lowerer.noLowering(`end with ${args.length} arguments`, call);
         // Forms: (), (cb), (chunk), (chunk, cb), (chunk, encoding, cb).
         let chunkNode;
         let cbArg;
         if (args.length === 1) {
-            const t = L.mapTypeOf(L.typeOf(args[0]));
+            const t = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
             if (t?.kind === "func")
                 cbArg = args[0];
             else
@@ -1580,64 +1579,64 @@ export function lowerStreamMethodCall(L, call, access, info) {
         }
         else if (args.length === 2) {
             chunkNode = args[0];
-            const t = L.mapTypeOf(L.typeOf(args[1]));
+            const t = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
             if (t?.kind === "string")
-                checkUtf8Encoding(L, "end", args[1]);
+                checkUtf8Encoding(lowerer, "end", args[1]);
             else
                 cbArg = args[1];
         }
         else if (args.length === 3) {
             chunkNode = args[0];
-            checkUtf8Encoding(L, "end", args[1]);
+            checkUtf8Encoding(lowerer, "end", args[1]);
             cbArg = args[2];
         }
-        const receiver = L.lowerExpr(access.expression);
+        const receiver = lowerer.lowerExpr(access.expression);
         let flags = 0;
         const tail = [];
         if (chunkNode !== undefined) {
             const kind = chunkKind(chunkNode);
             if (kind === "null" || kind === "union")
-                L.noLowering("end(null)", call);
+                lowerer.noLowering("end(null)", call);
             flags |= kind === "bytes" ? 1 : kind === "dyn" ? 8 : 2;
-            tail.push(kind === "bytes" ? L.lowerExprExpecting(chunkNode, BYTES)
-                : kind === "dyn" ? L.lowerExprExpecting(chunkNode, DYN)
-                    : L.lowerExprExpecting(chunkNode, STRING));
+            tail.push(kind === "bytes" ? lowerer.lowerExprExpecting(chunkNode, BYTES)
+                : kind === "dyn" ? lowerer.lowerExprExpecting(chunkNode, DYN)
+                    : lowerer.lowerExprExpecting(chunkNode, STRING));
         }
         if (cbArg !== undefined) {
-            const cb = L.lowerExprExpecting(cbArg, funcOf([], VOID));
+            const cb = lowerer.lowerExprExpecting(cbArg, funcOf([], VOID));
             if (cb.type.kind !== "func" || cb.type.params.length > 0) {
-                L.noLowering("end callbacks with parameters", cbArg, "() => void callbacks are supported");
+                lowerer.noLowering("end callbacks with parameters", cbArg, "() => void callbacks are supported");
             }
             flags |= 4;
             tail.push(cb);
         }
-        return { kind: "libCall", fn: "writable.end", args: [receiver, f64Lit(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)
-            L.noLowering(`${member} with arguments`, call);
-        const receiver = L.lowerExpr(access.expression);
+            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 };
     }
     if (member === "setEncoding") {
         requireSide(readableSide, "setEncoding");
         if (args.length !== 1) {
-            L.noLowering(`setEncoding with ${args.length} arguments`, call, "one literal encoding is the supported form");
+            lowerer.noLowering(`setEncoding with ${args.length} arguments`, call, "one literal encoding is the supported form");
         }
-        const enc = bufEncoding(L, "setEncoding", args[0]);
-        const receiver = L.lowerExpr(access.expression);
+        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 };
     }
     if (member === "setDefaultEncoding") {
         // The write-side default: utf8 IS the default — admit it; other
         // encodings would change what write(string) means.
         requireSide(writableSide, "setDefaultEncoding");
-        const t = args[0] ? L.typeOf(args[0]) : null;
+        const t = args[0] ? lowerer.typeOf(args[0]) : null;
         if (t?.isStringLiteralType() && (t.value === "utf8" || t.value === "utf-8")) {
-            return L.lowerExpr(access.expression);
+            return lowerer.lowerExpr(access.expression);
         }
-        L.noLowering("setDefaultEncoding", call, "utf8 (the default, as a compile-time literal) is the supported write-side string encoding");
+        lowerer.noLowering("setDefaultEncoding", call, "utf8 (the default, as a compile-time literal) is the supported write-side string encoding");
     }
     return null;
 }
@@ -1663,7 +1662,7 @@ const WS_BOOL_PROPS = new Set([
 const WS_NUM_PROPS = new Set([
     "length", "highWaterMark", "corked", "bufferedRequestCount",
 ]);
-export function lowerStreamStateProperty(L, expr) {
+export function lowerStreamStateProperty(lowerer, expr) {
     if (expr.questionDotToken)
         return null;
     const inner = expr.expression;
@@ -1674,34 +1673,34 @@ export function lowerStreamStateProperty(L, expr) {
         return null;
     let recvT;
     try {
-        recvT = L.mapTypeOf(L.typeOf(inner.expression));
+        recvT = lowerer.mapTypeOf(lowerer.typeOf(inner.expression));
     }
     catch {
         return null;
     }
     if (recvT?.kind !== "object")
         return null;
-    const info = L.classes.get(recvT.className);
-    const sides = streamSidesOf(L, info);
+    const info = lowerer.classes.get(recvT.className);
+    const sides = streamSidesOf(lowerer, info);
     if (!sides)
         return null;
     const loc = locOf(expr);
     const readable = stateName === "_readableState";
     if (readable ? sides === "w" : sides === "r") {
-        L.noLowering(`${stateName} on a ${recvT.className.slice(1)} (that half is absent)`, expr);
+        lowerer.noLowering(`${stateName} on a ${recvT.className.slice(1)} (that half is absent)`, expr);
     }
     const name = expr.name.text;
     const prefix = readable ? "rs:" : "ws:";
-    const receiver = () => L.lowerExpr(inner.expression);
+    const receiver = () => lowerer.lowerExpr(inner.expression);
     if (name === "flowing" && readable) {
-        const type = unionOf(L, [BOOL, { kind: "nullT" }]);
+        const type = unionOf(lowerer, [BOOL, { kind: "nullT" }]);
         const read = { kind: "libCall", fn: "readable.flowing", args: [receiver()], type, loc };
-        return L.maybeNarrow(read, expr);
+        return lowerer.maybeNarrow(read, expr);
     }
     if (name === "errored") {
-        const type = unionOf(L, [{ 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 L.maybeNarrow(read, expr);
+        return lowerer.maybeNarrow(read, expr);
     }
     const bools = readable ? RS_BOOL_PROPS : WS_BOOL_PROPS;
     const nums = readable ? RS_NUM_PROPS : WS_NUM_PROPS;
@@ -1714,7 +1713,7 @@ export function lowerStreamStateProperty(L, expr) {
             loc,
         };
     }
-    L.noLowering(`reading ${stateName}.${name}`, expr, "the lowered internal-state view covers the scalar fields (length, ended, flowing, errorEmitted, ...) — object-valued members like pipes and buffered entries have no lowering");
+    lowerer.noLowering(`reading ${stateName}.${name}`, expr, "the lowered internal-state view covers the scalar fields (length, ended, flowing, errorEmitted, ...) — object-valued members like pipes and buffered entries have no lowering");
 }
 /* ── the property surface ─────────────────────────────────────────────── */
 const READABLE_BOOL_PROPS = new Set(["readable", "readableEnded"]);
@@ -1724,8 +1723,8 @@ 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(L, expr, info) {
-    const sides = streamSidesOf(L, info);
+export function lowerStreamProperty(lowerer, expr, info) {
+    const sides = streamSidesOf(lowerer, info);
     if (!sides)
         return null;
     const name = expr.name.text;
@@ -1735,7 +1734,7 @@ export function lowerStreamProperty(L, expr, info) {
     const propCall = (type) => ({
         kind: "libCall",
         fn: "stream.prop",
-        args: [L.lowerExpr(expr.expression), strLit(name, loc)],
+        args: [lowerer.lowerExpr(expr.expression), strLit(name, loc)],
         type,
         loc,
     });
@@ -1746,14 +1745,14 @@ export function lowerStreamProperty(L, expr, info) {
         return propCall(F64);
     }
     if (name === "readableFlowing" && readableSide) {
-        const type = unionOf(L, [BOOL, { kind: "nullT" }]);
-        const read = { kind: "libCall", fn: "readable.flowing", args: [L.lowerExpr(expr.expression)], type, loc };
-        return L.maybeNarrow(read, expr);
+        const type = unionOf(lowerer, [BOOL, { kind: "nullT" }]);
+        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(L, [{ kind: "object", className: "%Error" }, { kind: "nullT" }]);
-        const read = { kind: "libCall", fn: "stream.errored", args: [L.lowerExpr(expr.expression)], type, loc };
-        return L.maybeNarrow(read, expr);
+        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) {
         // Runtime state: Readable.from streams answer true (object entries).