@scriptc/compiler 0.0.35 → 0.1.1

package/dist/frontend/lowering/{lower-emitter.js → lower-event-emitter.js}

@@ -39,10 +39,11 @@
 import * as ts from "../ts7/adapter.js";
 import { dynFallbackType, newFnCtx } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
-import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
+import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID } from "../../ir/ir.js";
 import { streamForcedTuple, streamSidesOf } from "./lower-stream.js";
+import { boolLit, strLit, varRef } from "../../ir/build.js";
 /** True when the class descends from (or is) the runtime emitter. */
-export function emitterRooted(L, info) {
+export function emitterRooted(lowerer, info) {
     for (let c = info ?? null; c; c = c.base) {
         if (c.builtinEmitter)
             return true;
@@ -58,8 +59,8 @@ const META_EVENTS = new Set(["newListener", "removeListener"]);
  * receiver classes resolve). The scan is DIAGNOSTIC-FREE: unmappable
  * types and non-literal names are simply not candidates — the touching
  * sites speak for themselves when they lower. */
-function emitterEvents(L) {
-    const holder = L;
+function emitterEvents(lowerer) {
+    const holder = lowerer;
     if (holder.emitterEventTable)
         return holder.emitterEventTable;
     const table = new Map();
@@ -73,7 +74,7 @@ function emitterEvents(L) {
     table.set("error", { tuple: [{ kind: "object", className: "%Error" }], fromEmit: true, conflict: null, dynListener: false });
     table.set("newListener", { tuple: [STRING], fromEmit: true, conflict: null, dynListener: false });
     table.set("removeListener", { tuple: [STRING], fromEmit: true, conflict: null, dynListener: false });
-    const fmt = (t) => L.fmt(t);
+    const fmt = (t) => lowerer.fmt(t);
     const mergeEmit = (name, args) => {
         if (args.some((a) => a === null))
             return; // its own site will diagnose
@@ -139,7 +140,7 @@ function emitterEvents(L) {
             }
         }
     };
-    for (const sf of L.program.getSourceFiles()) {
+    for (const sf of lowerer.program.getSourceFiles()) {
         if (sf.isDeclarationFile)
             continue;
         const walk = (node) => {
@@ -156,13 +157,13 @@ function emitterEvents(L) {
             let recvT = null;
             let nameT = null;
             try {
-                recvT = L.mapTypeOf(L.typeOf(node.expression.expression));
-                nameT = L.typeOf(arg0);
+                recvT = lowerer.mapTypeOf(lowerer.typeOf(node.expression.expression));
+                nameT = lowerer.typeOf(arg0);
             }
             catch {
                 return; // checker trouble is the lowering's business, not the scan's
             }
-            if (recvT?.kind !== "object" || !emitterRooted(L, L.classes.get(recvT.className)))
+            if (recvT?.kind !== "object" || !emitterRooted(lowerer, lowerer.classes.get(recvT.className)))
                 return;
             if (!nameT.isStringLiteralType())
                 return;
@@ -173,15 +174,15 @@ function emitterEvents(L) {
             // tuples (lower-stream.ts) — their sites never join the program-
             // global table, so a stream's 'data' cannot collide with a user
             // event named 'data' on a plain emitter.
-            if (streamForcedTuple(L, L.classes.get(recvT.className), name) !== null)
+            if (streamForcedTuple(lowerer, lowerer.classes.get(recvT.className), name) !== null)
                 return;
             try {
                 if (isEmit) {
-                    mergeEmit(name, node.arguments.slice(1).map((a) => L.mapTypeOf(L.typeOf(a))));
+                    mergeEmit(name, node.arguments.slice(1).map((a) => lowerer.mapTypeOf(lowerer.typeOf(a))));
                 }
                 else if (node.arguments[1]) {
-                    const cbCt = L.typeOf(node.arguments[1]);
-                    const cbT = L.mapTypeOf(cbCt) ?? dynFallbackType(L, node.arguments[1], cbCt);
+                    const cbCt = lowerer.typeOf(node.arguments[1]);
+                    const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, node.arguments[1], cbCt);
                     // Dyn-flavored listeners (a checked-dynamic value, or a func
                     // with dyn parameters — the JS lane) register through the
                     // adapter and constrain nothing: a dyn parameter accepts any
@@ -207,21 +208,19 @@ function emitterEvents(L) {
 /** The compile-time event name of the first argument, or a pointed fence
  * (string-literal TYPE, so const bindings and literal unions of one
  * member count — the staticHeaderKeyOf stance). */
-function eventNameOf(L, member, arg) {
-    const t = L.typeOf(arg);
+function eventNameOf(lowerer, member, arg) {
+    const t = lowerer.typeOf(arg);
     if (t.isStringLiteralType())
         return t.value;
-    L.noLowering(`${member} with a non-literal event name`, arg, "event names must be compile-time string literals (each event's argument tuple is unified statically; symbol names have no lowering)");
+    lowerer.noLowering(`${member} with a non-literal event name`, arg, "event names must be compile-time string literals (each event's argument tuple is unified statically; symbol names have no lowering)");
 }
-const strLit = (value, loc) => ({ kind: "strLit", value, type: STRING, loc });
-const boolLit = (value, loc) => ({ kind: "boolLit", value, type: BOOL, loc });
 /** The event's unified tuple, with conflicts reported at this site. */
-function tupleOf(L, table, name, blame) {
+function tupleOf(lowerer, table, name, blame) {
     const sig = table.get(name);
     if (!sig)
         return [];
     if (sig.conflict) {
-        L.noLowering(`the event '${name}' with conflicting argument types`, blame, `every emit site and listener of one event name must agree on one argument tuple — ${sig.conflict}`);
+        lowerer.noLowering(`the event '${name}' with conflicting argument types`, blame, `every emit site and listener of one event name must agree on one argument tuple — ${sig.conflict}`);
     }
     return sig.tuple;
 }
@@ -230,15 +229,15 @@ function tupleOf(L, table, name, blame) {
  * "func" for a function whose parameters include dyn (the JS lane's
  * unannotated listeners — their checker type is any). Null for everything
  * else (the static path, with its own diagnostics). */
-function dynListenerFlavor(L, node) {
+function dynListenerFlavor(lowerer, node) {
     let t;
     try {
-        const ct = L.typeOf(node);
+        const ct = lowerer.typeOf(node);
         // The JS declaration fallback is what the EXPRESSION lowering applies
         // to inference residue (an inline `(a) => {}` maps null as a checker
         // type but lowers as a dyn-parameter function) — classify by the same
         // rule, so the flavor always matches what lowerExpr will produce.
-        t = L.mapTypeOf(ct) ?? dynFallbackType(L, node, ct);
+        t = lowerer.mapTypeOf(ct) ?? dynFallbackType(lowerer, node, ct);
     }
     catch {
         return null;
@@ -251,7 +250,7 @@ function dynListenerFlavor(L, node) {
     // null): route it through the dyn path too — the registration helper's
     // checkListener throws Node's exact ERR_INVALID_ARG_TYPE TypeError
     // (the TS lane never reaches this: tsc rejects the argument first).
-    if (t && t.kind !== "jsval" && (isUnitType(t) || canConvertToDyn(t, (id) => L.shapes.get(id), (id) => L.unions.get(id)))) {
+    if (t && t.kind !== "jsval" && (isUnitType(t) || canConvertToDyn(t, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
         return "dyn";
     }
     return null;
@@ -277,25 +276,25 @@ function dynListenerFlavor(L, node) {
  * payloads — 'error' events), and the meta events (Node passes the
  * listener FUNCTION second, which has no dyn conversion — a dyn listener
  * reading it would see undefined). */
-function lowerDynListenerCall(L, member, name, tuple, receiver, cbNode, flavor, registering, once, prepend, loc, 
+function lowerDynListenerCall(lowerer, member, name, tuple, receiver, cbNode, flavor, registering, once, prepend, loc, 
 /** Stream 'data': the adapter registers through emitter.onDataDyn so
  * the backend emits the two-slot DATA thunk (box by runtime tag); the
  * tuple is [DYN] — the adapter passes the boxed chunk through. */
 streamData) {
     if (META_EVENTS.has(name)) {
-        L.noLowering(`'${member}' of '${name}' with a checked-dynamic listener`, cbNode, "Node passes the listener FUNCTION as the meta event's second argument, which has no dynamic conversion — annotate the listener's parameter as a string");
+        lowerer.noLowering(`'${member}' of '${name}' with a checked-dynamic listener`, cbNode, "Node passes the listener FUNCTION as the meta event's second argument, which has no dynamic conversion — annotate the listener's parameter as a string");
     }
-    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);
     for (let i = 0; i < tuple.length; i++) {
         const p = tuple[i];
         if (p.kind !== "dyn" && !canConvertToDyn(p, getRecord, getUnion)) {
-            L.noLowering(`'${member}' of '${name}' with a checked-dynamic listener`, cbNode, `the event's argument ${i} is '${L.fmt(p)}', which cannot box into a dynamic value — annotate the listener's parameters with the emitted types`);
+            lowerer.noLowering(`'${member}' of '${name}' with a checked-dynamic listener`, cbNode, `the event's argument ${i} is '${lowerer.fmt(p)}', which cannot box into a dynamic value — annotate the listener's parameters with the emitted types`);
         }
     }
     let cbDyn;
     if (flavor === "dyn") {
-        const v = L.lowerExpr(cbNode);
+        const v = lowerer.lowerExpr(cbNode);
         if (v.type.kind === "dyn") {
             cbDyn = v;
         }
@@ -306,13 +305,13 @@ streamData) {
             cbDyn = { kind: "dynFrom", value: v, type: DYN, loc };
         }
         else {
-            L.noLowering(`'${member}' with a non-function listener`, cbNode);
+            lowerer.noLowering(`'${member}' with a non-function listener`, cbNode);
         }
     }
     else {
-        const cb = L.lowerExpr(cbNode);
+        const cb = lowerer.lowerExpr(cbNode);
         if (cb.type.kind !== "func" || !canBoxFuncIntoDyn(cb.type, getRecord, getUnion)) {
-            L.noLowering(`'${member}' with a listener of this signature`, cbNode, "a checked-dynamic listener's own parameters and return must box across the dynamic boundary");
+            lowerer.noLowering(`'${member}' with a listener of this signature`, cbNode, "a checked-dynamic listener's own parameters and return must box across the dynamic boundary");
         }
         cbDyn = { kind: "dynFrom", value: cb, type: DYN, loc };
     }
@@ -322,15 +321,14 @@ streamData) {
     const key = registering
         ? `${onFn}:${typeKey(recvT)}:${typeKey(adapterT)}`
         : `emitter.offDyn:${typeKey(recvT)}`;
-    const existing = L.arrHofHelpers.get(key);
+    const existing = lowerer.arrHofHelpers.get(key);
     let helper = existing;
     if (!helper) {
-        helper = `%emitter.${registering ? "onDyn" : "offDyn"}.${L.arrHofHelpers.size}`;
-        L.arrHofHelpers.set(key, helper);
-        const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
+        helper = `%emitter.${registering ? "onDyn" : "offDyn"}.${lowerer.arrHofHelpers.size}`;
+        lowerer.arrHofHelpers.set(key, helper);
         const check = {
             kind: "exprStmt",
-            expr: { kind: "libCall", fn: "emitter.checkListener", args: [ref("cb.0", DYN)], type: VOID, loc },
+            expr: { kind: "libCall", fn: "emitter.checkListener", args: [varRef("cb.0", DYN, loc)], type: VOID, loc },
             loc,
         };
         const params = [
@@ -350,13 +348,13 @@ streamData) {
             locals.push({ id: "a.0", name: "a", type: adapterT, mutable: false });
             body = [
                 check,
-                { kind: "varDecl", localId: "a.0", init: { kind: "dynCheck", value: ref("cb.0", DYN), type: adapterT, loc }, loc },
+                { kind: "varDecl", localId: "a.0", init: { kind: "dynCheck", value: varRef("cb.0", DYN, loc), type: adapterT, loc }, loc },
                 {
                     kind: "return",
                     value: {
                         kind: "libCall",
                         fn: onFn,
-                        args: [ref("r.0", recvT), ref("n.0", STRING), ref("cb.0", DYN), ref("a.0", adapterT), ref("o.0", BOOL), ref("p.0", BOOL)],
+                        args: [varRef("r.0", recvT, loc), varRef("n.0", STRING, loc), varRef("cb.0", DYN, loc), varRef("a.0", adapterT, loc), varRef("o.0", BOOL, loc), varRef("p.0", BOOL, loc)],
                         type: recvT,
                         loc,
                     },
@@ -372,7 +370,7 @@ streamData) {
                     value: {
                         kind: "libCall",
                         fn: "emitter.offDyn",
-                        args: [ref("r.0", recvT), ref("n.0", STRING), ref("cb.0", DYN)],
+                        args: [varRef("r.0", recvT, loc), varRef("n.0", STRING, loc), varRef("cb.0", DYN, loc)],
                         type: recvT,
                         loc,
                     },
@@ -380,7 +378,7 @@ streamData) {
                 },
             ];
         }
-        L.liftedFns.push({ name: helper, params, returnType: recvT, locals, body, loc });
+        lowerer.liftedFns.push({ name: helper, params, returnType: recvT, locals, body, loc });
     }
     return {
         kind: "call",
@@ -394,7 +392,7 @@ streamData) {
 }
 /** A listener argument: lowered, checked void-returning, and its
  * parameters checked as a typeEquals PREFIX of the event tuple. */
-function lowerListenerArg(L, member, name, node, tuple) {
+function lowerListenerArg(lowerer, member, name, node, tuple) {
     // Unannotated non-empty parameter lists have no static types (checker
     // `any`; dyn in JS sources) — say so before the blanket type fence speaks.
     if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && node.parameters.length > 0) {
@@ -402,21 +400,21 @@ function lowerListenerArg(L, member, name, node, tuple) {
             if (p.type === undefined && ts.isIdentifier(p.name)) {
                 const mapped = (() => {
                     try {
-                        return L.mapTypeOf(L.typeOf(p.name));
+                        return lowerer.mapTypeOf(lowerer.typeOf(p.name));
                     }
                     catch {
                         return null;
                     }
                 })();
                 if (mapped === null || mapped.kind === "dyn" || mapped.kind === "jsval") {
-                    L.noLowering(`'${member}' listeners with unannotated parameters`, p, "EventEmitter's declared listener type is (...args: any[]) — annotate each parameter with the emitted argument's type");
+                    lowerer.noLowering(`'${member}' listeners with unannotated parameters`, p, "EventEmitter's declared listener type is (...args: any[]) — annotate each parameter with the emitted argument's type");
                 }
             }
         }
     }
-    const cb = L.lowerExpr(node);
+    const cb = lowerer.lowerExpr(node);
     if (cb.type.kind !== "func") {
-        L.noLowering(`'${member}' with a non-function listener`, node);
+        lowerer.noLowering(`'${member}' with a non-function listener`, node);
     }
     const cbT = cb.type;
     // Node ignores listener return values, so value-returning listeners
@@ -425,14 +423,14 @@ function lowerListenerArg(L, member, name, node, tuple) {
     // and discards (releasing refcounted results). An async listener's
     // promise is abandoned unobserved (SEMANTICS.md).
     if (META_EVENTS.has(name) && cbT.params.length > 1) {
-        L.noLowering(`'${name}' listeners taking the listener-function argument`, node, "meta-event listeners take at most the event name (the listener argument has no unified static type)");
+        lowerer.noLowering(`'${name}' listeners taking the listener-function argument`, node, "meta-event listeners take at most the event name (the listener argument has no unified static type)");
     }
     if (cbT.params.length > tuple.length) {
-        L.noLowering(`a '${name}' listener declaring ${cbT.params.length} parameters where the event's tuple has ${tuple.length}`, node, "listeners may declare a prefix of the event's emitted arguments");
+        lowerer.noLowering(`a '${name}' listener declaring ${cbT.params.length} parameters where the event's tuple has ${tuple.length}`, node, "listeners may declare a prefix of the event's emitted arguments");
     }
     for (let i = 0; i < cbT.params.length; i++) {
         if (!typeEquals(cbT.params[i], tuple[i])) {
-            L.noLowering(`a '${name}' listener whose parameter ${i} is '${L.fmt(cbT.params[i])}' where the event's tuple has '${L.fmt(tuple[i])}'`, node, "every emit site and listener of one event name must agree on one argument tuple");
+            lowerer.noLowering(`a '${name}' listener whose parameter ${i} is '${lowerer.fmt(cbT.params[i])}' where the event's tuple has '${lowerer.fmt(tuple[i])}'`, node, "every emit site and listener of one event name must agree on one argument tuple");
         }
     }
     return cb;
@@ -446,11 +444,11 @@ function lowerListenerArg(L, member, name, node, tuple) {
  * NEVER dispatches through an override at-or-below the lexical class —
  * JS's static super dispatch (the nearest override STRICTLY ABOVE the
  * lexical class still answers, exactly like a prototype-chain walk). */
-export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
+export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
     const member = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
-    const lowerReceiver = () => superRecv?.thisRef ?? L.lowerExpr(access.expression);
+    const lowerReceiver = () => superRecv?.thisRef ?? lowerer.lowerExpr(access.expression);
     // The class VALUE, not an instance (`EventEmitter.setMaxListeners(n)` —
     // the receiver's checker type carries construct signatures; mapType
     // answers the instance object for every EventEmitter-symbol type, so the
@@ -459,13 +457,13 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
     // are a DIFFERENT surface: setMaxListeners(n) writes the process-wide
     // defaultMaxListeners (validated at runtime — Node's ERR_OUT_OF_RANGE);
     // everything else fences by its static name.
-    if (superRecv === undefined && L.checker.getConstructSignatures(L.typeOf(access.expression)).length > 0) {
+    if (superRecv === undefined && lowerer.checker.getConstructSignatures(lowerer.typeOf(access.expression)).length > 0) {
         if (member === "setMaxListeners" && args.length === 1) {
-            if (L.mapTypeOf(L.typeOf(args[0]))?.kind !== "f64") {
+            if (lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind !== "f64") {
                 // Node's runtime ladder over the dyn value ("setMaxListeners" is
                 // the message's slot for the static form).
-                const raw = L.lowerExpr(args[0]);
-                if (raw.type.kind === "dyn" || raw.kind === "unitLit" || L.dynConvertible(raw.type)) {
+                const raw = lowerer.lowerExpr(args[0]);
+                if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
                     const n = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
                     return {
                         kind: "libCall",
@@ -476,9 +474,9 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
                     };
                 }
             }
-            const n = L.lowerExprExpecting(args[0], F64);
+            const n = lowerer.lowerExprExpecting(args[0], F64);
             if (n.type.kind !== "f64") {
-                L.noLowering(`EventEmitter.setMaxListeners with a '${L.fmt(n.type)}' argument`, args[0], "the lowered form takes a number (Node throws ERR_INVALID_ARG_TYPE at runtime for other values)");
+                lowerer.noLowering(`EventEmitter.setMaxListeners with a '${lowerer.fmt(n.type)}' argument`, args[0], "the lowered form takes a number (Node throws ERR_INVALID_ARG_TYPE at runtime for other values)");
             }
             return { kind: "libCall", fn: "emitter.setDefaultMax", args: [n], type: VOID, loc };
         }
@@ -489,14 +487,14 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
             // when n is a pure read (identifier/literal — nothing to evaluate)
             // and the target crosses into the checked-dynamic tree for the Received tail.
             if (args.length === 2 && !args.some(ts.isSpreadElement)) {
-                const nT = L.mapTypeOf(L.typeOf(args[0]));
-                const tT = L.mapTypeOf(L.typeOf(args[1]));
+                const nT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
+                const tT = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
                 const nPure = ts.isIdentifier(args[0]) || ts.isLiteralExpression(args[0]);
                 const targetNotEmitter = tT !== null && tT.kind !== "dyn" && tT.kind !== "jsval" &&
                     !(tT.kind === "object");
                 if (nT?.kind === "f64" && nPure && targetNotEmitter) {
-                    const raw = L.lowerExpr(args[1]);
-                    if (raw.type.kind === "dyn" || raw.kind === "unitLit" || L.dynConvertible(raw.type)) {
+                    const raw = lowerer.lowerExpr(args[1]);
+                    if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
                         const got = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
                         return {
                             kind: "libCall",
@@ -512,20 +510,20 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
                     }
                 }
             }
-            L.noLowering(`EventEmitter.setMaxListeners with ${args.length} arguments`, call, "the lowered static form is EventEmitter.setMaxListeners(n) — per-target application (…, ...eventTargets) has no lowering; call target.setMaxListeners(n) instead");
+            lowerer.noLowering(`EventEmitter.setMaxListeners with ${args.length} arguments`, call, "the lowered static form is EventEmitter.setMaxListeners(n) — per-target application (…, ...eventTargets) has no lowering; call target.setMaxListeners(n) instead");
         }
-        L.noLowering(`the static EventEmitter.${member} form`, call, "instance emitters lower this member; the class-value statics have no lowering yet");
+        lowerer.noLowering(`the static EventEmitter.${member} form`, call, "instance emitters lower this member; the class-value statics have no lowering yet");
     }
-    const table = emitterEvents(L);
+    const table = emitterEvents(lowerer);
     if (REGISTER_MEMBERS.has(member) || member === "off" || member === "removeListener") {
         // Node's (type, listener) signature IGNORES extra arguments — admit
         // pure-read extras (literals/identifiers: nothing to evaluate) and
         // drop them; anything with effects keeps the fence.
         const extrasPure = args.slice(2).every((a) => ts.isIdentifier(a) || ts.isLiteralExpression(a));
         if (args.length < 2 || !extrasPure) {
-            L.noLowering(`${member} with ${args.length} arguments`, call, "the supported form is (eventName, listener)");
+            lowerer.noLowering(`${member} with ${args.length} arguments`, call, "the supported form is (eventName, listener)");
         }
-        const name = eventNameOf(L, member, args[0]);
+        const name = eventNameOf(lowerer, member, args[0]);
         const registering = REGISTER_MEMBERS.has(member);
         // The runtime fires the meta events INTERNALLY (scr_ee_emit_meta —
         // Node calls this.emit, which would dispatch through an emit
@@ -535,7 +533,7 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
         if (registering && META_EVENTS.has(name)) {
             const ov = emitOverrideComparable(info);
             if (ov) {
-                L.noLowering(`'${member}' of '${name}' while '${ov.def.jsName || ov.def.name}' overrides emit`, call, "the runtime fires meta events internally, which cannot route through an emit override");
+                lowerer.noLowering(`'${member}' of '${name}' while '${ov.def.jsName || ov.def.name}' overrides emit`, call, "the runtime fires meta events internally, which cannot route through an emit override");
             }
         }
         const receiver = lowerReceiver();
@@ -545,23 +543,23 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
         // encoded streams deliver strings; scr_stream_emit_data): listeners
         // on readable-sided receivers register through DATA thunks that
         // unwrap the declared side (typed) or box by tag (dyn).
-        const sides = streamSidesOf(L, info);
+        const sides = streamSidesOf(lowerer, info);
         if (name === "data" && (sides === "r" || sides === "rw")) {
-            const dynFlavor = dynListenerFlavor(L, args[1]);
+            const dynFlavor = dynListenerFlavor(lowerer, args[1]);
             if (dynFlavor !== null) {
-                return lowerDynListenerCall(L, member, name, [DYN], receiver, args[1], dynFlavor, registering, once, prepend, loc, true);
+                return lowerDynListenerCall(lowerer, member, name, [DYN], receiver, args[1], dynFlavor, registering, once, prepend, loc, true);
             }
-            const cb = L.lowerExpr(args[1]);
+            const cb = lowerer.lowerExpr(args[1]);
             if (cb.type.kind !== "func") {
-                L.noLowering(`'${member}' with a non-function listener`, args[1]);
+                lowerer.noLowering(`'${member}' with a non-function listener`, args[1]);
             }
             const cbT = cb.type;
             if (cbT.params.length > 1) {
-                L.noLowering(`a 'data' listener declaring ${cbT.params.length} parameters where the event carries one chunk`, args[1]);
+                lowerer.noLowering(`a 'data' listener declaring ${cbT.params.length} parameters where the event carries one chunk`, args[1]);
             }
             const p = cbT.params[0];
             if (p !== undefined && !(p.kind === "bytes" && p.elem === "u8") && p.kind !== "string") {
-                L.noLowering(`a 'data' listener whose chunk parameter is '${L.fmt(p)}'`, args[1], "chunks are Buffers — or strings once setEncoding/the encoding option applies");
+                lowerer.noLowering(`a 'data' listener whose chunk parameter is '${lowerer.fmt(p)}'`, args[1], "chunks are Buffers — or strings once setEncoding/the encoding option applies");
             }
             if (!registering) {
                 return {
@@ -583,12 +581,12 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
         // Stream-rooted receivers consult the per-base FORCED tuples first
         // (runtime-emitted 'end'/'pipe'/... payloads); the dyn-listener check
         // below then sees the forced tuple exactly like a table one.
-        const tuple = streamForcedTuple(L, info, name) ?? tupleOf(L, table, name, call);
-        const dynFlavor = dynListenerFlavor(L, args[1]);
+        const tuple = streamForcedTuple(lowerer, info, name) ?? tupleOf(lowerer, table, name, call);
+        const dynFlavor = dynListenerFlavor(lowerer, args[1]);
         if (dynFlavor !== null) {
-            return lowerDynListenerCall(L, member, name, tuple, receiver, args[1], dynFlavor, registering, once, prepend, loc, false);
+            return lowerDynListenerCall(lowerer, member, name, tuple, receiver, args[1], dynFlavor, registering, once, prepend, loc, false);
         }
-        const cb = lowerListenerArg(L, member, name, args[1], tuple);
+        const cb = lowerListenerArg(lowerer, member, name, args[1], tuple);
         return {
             kind: "libCall",
             fn: registering ? "emitter.on" : "emitter.off",
@@ -601,41 +599,41 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
     }
     if (member === "emit") {
         if (args.length === 0) {
-            L.noLowering("emit without an event name", call);
+            lowerer.noLowering("emit without an event name", call);
         }
-        const name = eventNameOf(L, member, args[0]);
+        const name = eventNameOf(lowerer, member, args[0]);
         const receiver = lowerReceiver();
         if (name === "error") {
             // The special event: exactly one %Error-rooted payload; no listener
             // means the runtime THROWS it (emitter.emitError, may-throw).
             if (args.length !== 2) {
-                L.noLowering(`emit('error') with ${args.length - 1} payload arguments`, call, "the supported form is emit('error', err) with an Error-hierarchy payload (non-Error payloads would need Node's ERR_UNHANDLED_ERROR wrapping — no lowering yet)");
+                lowerer.noLowering(`emit('error') with ${args.length - 1} payload arguments`, call, "the supported form is emit('error', err) with an Error-hierarchy payload (non-Error payloads would need Node's ERR_UNHANDLED_ERROR wrapping — no lowering yet)");
             }
-            const err = L.lowerExpr(args[1]);
+            const err = lowerer.lowerExpr(args[1]);
             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(`emit('error') with a '${L.fmt(err.type)}' payload`, args[1], "the supported payload is an Error-hierarchy instance");
+                lowerer.noLowering(`emit('error') with a '${lowerer.fmt(err.type)}' payload`, args[1], "the supported payload is an Error-hierarchy instance");
             }
-            return emitDispatchExpr(L, info, name, [{ kind: "object", className: "%Error" }], receiver, [L.upcastTo(err, "%Error")], superRecv?.cls, loc);
+            return emitDispatchExpr(lowerer, info, name, [{ kind: "object", className: "%Error" }], receiver, [lowerer.upcastTo(err, "%Error")], superRecv?.cls, loc);
         }
         // Stream 'data' rides the two-slot payload ABI: a user emit fills
         // the chunk's slot (bytes or string), NULLs the other.
-        const emitSides = streamSidesOf(L, info);
+        const emitSides = streamSidesOf(lowerer, info);
         if (name === "data" && (emitSides === "r" || emitSides === "rw")) {
             if (args.length !== 2) {
-                L.noLowering(`emit('data') with ${args.length - 1} payload arguments`, call, "the event carries one chunk (a Buffer or string)");
+                lowerer.noLowering(`emit('data') with ${args.length - 1} payload arguments`, call, "the event carries one chunk (a Buffer or string)");
             }
-            const chunk = L.lowerExpr(args[1]);
+            const chunk = lowerer.lowerExpr(args[1]);
             if (!(chunk.type.kind === "bytes" && chunk.type.elem === "u8") && chunk.type.kind !== "string") {
-                L.noLowering(`emit('data') with a '${L.fmt(chunk.type)}' chunk`, args[1], "chunks are Buffers or strings");
+                lowerer.noLowering(`emit('data') with a '${lowerer.fmt(chunk.type)}' chunk`, args[1], "chunks are Buffers or strings");
             }
             return {
                 kind: "libCall",
@@ -645,25 +643,25 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
                 loc,
             };
         }
-        const tuple = streamForcedTuple(L, info, name) ?? tupleOf(L, table, name, call);
+        const tuple = streamForcedTuple(lowerer, info, name) ?? tupleOf(lowerer, table, name, call);
         if (args.length - 1 !== tuple.length) {
-            L.noLowering(`emit('${name}') with ${args.length - 1} arguments where the event's tuple has ${tuple.length}`, call, "every emit site of one event name must supply the same argument tuple (listeners may declare a prefix)");
+            lowerer.noLowering(`emit('${name}') with ${args.length - 1} arguments where the event's tuple has ${tuple.length}`, call, "every emit site of one event name must supply the same argument tuple (listeners may declare a prefix)");
         }
-        const payload = args.slice(1).map((a, i) => L.lowerExprExpecting(a, tuple[i]));
-        return emitDispatchExpr(L, info, name, tuple, receiver, payload, superRecv?.cls, loc);
+        const payload = args.slice(1).map((a, i) => lowerer.lowerExprExpecting(a, tuple[i]));
+        return emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superRecv?.cls, loc);
     }
     // The pure-introspection members take ANY string-typed name — no tuple
     // is involved, so the literal rule has nothing to protect (a meta
     // listener naturally passes its name parameter along).
     if (member === "removeAllListeners") {
         if (args.length > 1) {
-            L.noLowering(`removeAllListeners with ${args.length} arguments`, call);
+            lowerer.noLowering(`removeAllListeners with ${args.length} arguments`, call);
         }
         const all = args.length === 0;
         const receiver = lowerReceiver();
-        const name = all ? strLit("", loc) : L.lowerExprExpecting(args[0], STRING);
+        const name = all ? strLit("", loc) : lowerer.lowerExprExpecting(args[0], STRING);
         if (name.type.kind !== "string") {
-            L.noLowering(`removeAllListeners with a '${L.fmt(name.type)}' event name`, args[0] ?? call);
+            lowerer.noLowering(`removeAllListeners with a '${lowerer.fmt(name.type)}' event name`, args[0] ?? call);
         }
         return {
             kind: "libCall",
@@ -675,19 +673,19 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
     }
     if (member === "listenerCount") {
         if (args.length !== 1 && args.length !== 2) {
-            L.noLowering(`listenerCount with ${args.length} arguments`, call);
+            lowerer.noLowering(`listenerCount with ${args.length} arguments`, call);
         }
         const receiver = lowerReceiver();
-        const name = L.lowerExprExpecting(args[0], STRING);
+        const name = lowerer.lowerExprExpecting(args[0], STRING);
         if (name.type.kind !== "string") {
-            L.noLowering(`listenerCount with a '${L.fmt(name.type)}' event name`, args[0]);
+            lowerer.noLowering(`listenerCount with a '${lowerer.fmt(name.type)}' event name`, args[0]);
         }
         if (args.length === 2) {
             // The fn filter matches by identity — the listener's own type is
             // its word; no tuple check is needed to count.
-            const cb = L.lowerExpr(args[1]);
+            const cb = lowerer.lowerExpr(args[1]);
             if (cb.type.kind !== "func") {
-                L.noLowering(`listenerCount with a non-function filter`, args[1]);
+                lowerer.noLowering(`listenerCount with a non-function filter`, args[1]);
             }
             return { kind: "libCall", fn: "emitter.countFn", args: [receiver, name, cb], type: F64, loc };
         }
@@ -704,16 +702,16 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
         // once wrapper is runtime-internal, so rawListeners' wrapper identity
         // is a documented divergence (SEMANTICS.md).
         if (args.length !== 1) {
-            L.noLowering(`${member} with ${args.length} arguments`, call, "the supported form is (eventName)");
+            lowerer.noLowering(`${member} with ${args.length} arguments`, call, "the supported form is (eventName)");
         }
-        const name = eventNameOf(L, member, args[0]);
+        const name = eventNameOf(lowerer, member, args[0]);
         const sig = table.get(name);
         if (sig?.dynListener) {
             // A dyn-adapted registration means the runtime bucket can hold
             // originals of MIXED signatures — no one honest element type.
-            L.noLowering(`${member} of the event '${name}'`, call, "a listener of this event is checked-dynamic (unannotated parameters), so the listener array has no one static element type — listenerCount(name) counts");
+            lowerer.noLowering(`${member} of the event '${name}'`, call, "a listener of this event is checked-dynamic (unannotated parameters), so the listener array has no one static element type — listenerCount(name) counts");
         }
-        const tuple = tupleOf(L, table, name, call);
+        const tuple = tupleOf(lowerer, table, name, call);
         const receiver = lowerReceiver();
         return {
             kind: "libCall",
@@ -725,30 +723,30 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
     }
     if (member === "eventNames") {
         if (args.length !== 0)
-            L.noLowering(`eventNames with ${args.length} arguments`, call);
+            lowerer.noLowering(`eventNames with ${args.length} arguments`, call);
         const receiver = lowerReceiver();
         return { kind: "libCall", fn: "emitter.names", args: [receiver], type: arrayOf(STRING), loc };
     }
     if (member === "setMaxListeners") {
         if (args.length !== 1)
-            L.noLowering(`setMaxListeners with ${args.length} arguments`, call);
+            lowerer.noLowering(`setMaxListeners with ${args.length} arguments`, call);
         const receiver = lowerReceiver();
-        if (L.mapTypeOf(L.typeOf(args[0]))?.kind !== "f64") {
+        if (lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind !== "f64") {
             // The invalid-input probes (string n, dyn helpers): Node's ladder
             // runs at runtime — ERR_INVALID_ARG_TYPE for non-numbers,
             // ERR_OUT_OF_RANGE below zero, and a well-typed dyn still applies.
-            const raw = L.lowerExpr(args[0]);
-            if (raw.type.kind === "dyn" || raw.kind === "unitLit" || L.dynConvertible(raw.type)) {
+            const raw = lowerer.lowerExpr(args[0]);
+            if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
                 const n = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
                 return { kind: "libCall", fn: "emitter.setMaxChk", args: [receiver, n], type: receiver.type, loc };
             }
         }
-        const n = L.lowerExprExpecting(args[0], F64);
+        const n = lowerer.lowerExprExpecting(args[0], F64);
         return { kind: "libCall", fn: "emitter.setMax", args: [receiver, n], type: receiver.type, loc };
     }
     if (member === "getMaxListeners") {
         if (args.length !== 0)
-            L.noLowering(`getMaxListeners with ${args.length} arguments`, call);
+            lowerer.noLowering(`getMaxListeners with ${args.length} arguments`, call);
         const receiver = lowerReceiver();
         return { kind: "libCall", fn: "emitter.getMax", args: [receiver], type: F64, loc };
     }
@@ -757,7 +755,7 @@ export function lowerEmitterMethodCall(L, call, access, info, superRecv) {
 /** Why a subclass `emit` declaration is NOT the forwarding shape, or null
  * when it conforms. Checked at class collection; the recorded override
  * then lowers per event with no further shape questions. */
-export function emitOverrideShapeReason(L, member) {
+export function emitOverrideShapeReason(lowerer, member) {
     if (!member.body)
         return "the declaration has no body";
     if (member.asteriskToken !== undefined)
@@ -793,14 +791,14 @@ export function emitOverrideShapeReason(L, member) {
         // lowering anyway). JS: unannotated is the only spelling (checker
         // `any`); the specialization binds it as the string it always is —
         // event names are compile-time literals program-wide.
-        const p0T = L.mapTypeOf(L.typeOf(p0.name));
+        const p0T = lowerer.mapTypeOf(lowerer.typeOf(p0.name));
         const jsUnannotated = p0.type === undefined && isJsSourceFile(member.getSourceFile()) &&
             (p0T === null || p0T.kind === "dyn" || p0T.kind === "jsval");
         if (p0T?.kind !== "string" && !jsUnannotated) {
             return "the event parameter must be typed 'string' (symbol event names have no lowering)";
         }
-        const sig = L.checker.getSignatureFromDeclaration(member);
-        const ret = sig ? L.mapTypeOf(L.checker.getReturnTypeOfSignature(sig)) : null;
+        const sig = lowerer.checker.getSignatureFromDeclaration(member);
+        const ret = sig ? lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(sig)) : null;
         if (ret?.kind !== "bool") {
             return "every code path must return a boolean (emit's contract)";
         }
@@ -808,8 +806,8 @@ export function emitOverrideShapeReason(L, member) {
     catch {
         return "its signature does not resolve statically";
     }
-    const eventSym = L.checker.getSymbolAtLocation(p0.name);
-    const restSym = L.checker.getSymbolAtLocation(p1.name);
+    const eventSym = lowerer.checker.getSymbolAtLocation(p0.name);
+    const restSym = lowerer.checker.getSymbolAtLocation(p1.name);
     if (!eventSym || !restSym)
         return "its parameters do not resolve statically";
     let reason = null;
@@ -819,12 +817,12 @@ export function emitOverrideShapeReason(L, member) {
         if (ts.isIdentifier(n)) {
             let s;
             try {
-                s = L.checker.getSymbolAtLocation(n) ?? undefined;
+                s = lowerer.checker.getSymbolAtLocation(n) ?? undefined;
             }
             catch {
                 s = undefined;
             }
-            if (s === restSym && !isEmitForwardSpread(L, member, n, eventSym)) {
+            if (s === restSym && !isEmitForwardSpread(lowerer, member, n, eventSym)) {
                 reason = "the rest parameter may only forward through super.emit(event, ...args) in the method's own body";
             }
             else if (s === eventSym && n !== p0.name && isWriteTarget(n)) {
@@ -840,7 +838,7 @@ export function emitOverrideShapeReason(L, member) {
  * `super.emit(<event param>, ...<this identifier>)`, two arguments, sitting
  * in the override method's OWN body (a nested function could not reach the
  * specialization's tuple parameters). */
-function isEmitForwardSpread(L, method, id, eventSym) {
+function isEmitForwardSpread(lowerer, method, id, eventSym) {
     const sp = id.parent;
     if (!ts.isSpreadElement(sp) || sp.expression !== id)
         return false;
@@ -857,7 +855,7 @@ function isEmitForwardSpread(L, method, id, eventSym) {
     if (!ts.isIdentifier(a0))
         return false;
     try {
-        if (L.checker.getSymbolAtLocation(a0) !== eventSym)
+        if (lowerer.checker.getSymbolAtLocation(a0) !== eventSym)
             return false;
     }
     catch {
@@ -903,7 +901,7 @@ function isWriteTarget(id) {
     }
 }
 /** The nearest class at-or-above `info` declaring an emit override. */
-export function emitOverrideAtOrAbove(info) {
+function emitOverrideAtOrAbove(info) {
     for (let c = info ?? null; c; c = c.base) {
         if (c.emitOverride)
             return c;
@@ -937,7 +935,7 @@ function topmostEmitOverridesBelow(info) {
 /** An emit-override class COMPARABLE to `info` (ancestor-or-self or
  * descendant — a dynamic instance under this static type could dispatch
  * through it), or null. The meta-registration fence's test. */
-export function emitOverrideComparable(info) {
+function emitOverrideComparable(info) {
     const above = emitOverrideAtOrAbove(info);
     if (above)
         return above;
@@ -949,12 +947,12 @@ export function emitOverrideComparable(info) {
  * method on the class (vtable participation — the ABI is `(this, ...tuple)
  * => bool` for every declarer of one event, override-exact by
  * construction) and queues the body for the drive loop's fixpoint. */
-export function ensureEmitSpec(L, info, event, tuple) {
+function ensureEmitSpec(lowerer, info, event, tuple) {
     const mName = `emit:${event}`;
     const key = `%${info.def.name}.${mName}`;
-    if (L.emitSpecDone.has(key))
+    if (lowerer.emitSpecDone.has(key))
         return;
-    L.emitSpecDone.add(key);
+    lowerer.emitSpecDone.add(key);
     if (!info.methods.has(mName)) {
         info.methods.set(mName, { params: tuple.map((t) => ({ type: t, mode: "required" })), ret: BOOL });
         if (info.def.methods)
@@ -962,56 +960,56 @@ export function ensureEmitSpec(L, info, event, tuple) {
         else
             info.def.methods = [mName];
     }
-    const ordinal = L.emitSpecQueue.filter((q) => q.info === info).length;
-    L.emitSpecQueue.push({ info, event, tuple, ordinal });
+    const ordinal = lowerer.emitSpecQueue.filter((q) => q.info === info).length;
+    lowerer.emitSpecQueue.push({ info, event, tuple, ordinal });
 }
 /** One specialization body: the override method's statements lowered with
  * `event` bound to the name and hidden tuple parameters standing in for
  * the rest parameter (readable ONLY through the super-forward, which the
  * collection shape check guaranteed). */
-export function lowerEmitOverrideSpec(L, req) {
+export function lowerEmitOverrideSpec(lowerer, req) {
     const { info, event, tuple, ordinal } = req;
     const ov = info.emitOverride;
     if (!ov?.decl.body)
         return null;
     const className = info.def.name;
     const thisType = { kind: "object", className };
-    const prevClass = L.currentClass;
-    const prevSpec = L.emitSpecCtx;
-    const prevSuppress = L.suppressStats;
-    L.currentClass = info;
-    L.suppressStats = prevSuppress || ordinal > 0;
-    L.fnStack.push(newFnCtx(false, null, null, BOOL));
+    const prevClass = lowerer.currentClass;
+    const prevSpec = lowerer.emitSpecCtx;
+    const prevSuppress = lowerer.suppressStats;
+    lowerer.currentClass = info;
+    lowerer.suppressStats = prevSuppress || ordinal > 0;
+    lowerer.fnStack.push(newFnCtx(false, null, null, BOOL));
     try {
         const loc = locOf(ov.decl);
-        const thisLocal = L.declareThis(thisType);
+        const thisLocal = lowerer.declareThis(thisType);
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
         const tupleParams = tuple.map((t, i) => {
-            const p = L.declareHiddenLocal(`%ee${i}`, t);
+            const p = lowerer.declareHiddenLocal(`%ee${i}`, t);
             params.push({ localId: p.id, name: `%ee${i}`, type: t });
             return p;
         });
         const eventDecl = ov.decl.parameters[0];
-        const eventLocal = L.declareLocal(eventDecl.name, ts.isIdentifier(eventDecl.name) ? eventDecl.name.text : "event", STRING, true);
+        const eventLocal = lowerer.declareLocal(eventDecl.name, ts.isIdentifier(eventDecl.name) ? eventDecl.name.text : "event", STRING, true);
         const prologue = [
             { kind: "varDecl", localId: eventLocal.id, init: strLit(event, loc), loc },
         ];
-        L.emitSpecCtx = { info, event, tuple, eventSym: ov.eventSym, restSym: ov.restSym, tupleParams };
-        const body = [...prologue, ...L.lowerStmts(ov.decl.body.statements)];
+        lowerer.emitSpecCtx = { info, event, tuple, eventSym: ov.eventSym, restSym: ov.restSym, tupleParams };
+        const body = [...prologue, ...lowerer.lowerStmts(ov.decl.body.statements)];
         return {
             name: `%${className}.emit:${event}`,
             params,
             returnType: BOOL,
-            locals: L.ctx.locals,
+            locals: lowerer.ctx.locals,
             body,
             loc,
         };
     }
     finally {
-        L.emitSpecCtx = prevSpec;
-        L.fnStack.pop();
-        L.currentClass = prevClass;
-        L.suppressStats = prevSuppress;
+        lowerer.emitSpecCtx = prevSpec;
+        lowerer.fnStack.pop();
+        lowerer.currentClass = prevClass;
+        lowerer.suppressStats = prevSuppress;
     }
 }
 /** The specialization body's `super.emit(event, ...args)` — matched
@@ -1020,30 +1018,30 @@ export function lowerEmitOverrideSpec(L, req) {
  * override ancestor's specialization (JS's super chain) or the runtime
  * emit. Null when the call is not the forward (a literal-name super.emit
  * rides the general super-emitter route). */
-export function emitSpecSuperForward(L, call, access) {
-    const ctx = L.emitSpecCtx;
+export function emitSpecSuperForward(lowerer, call, access) {
+    const ctx = lowerer.emitSpecCtx;
     if (!ctx || access.name.text !== "emit" || call.arguments.length !== 2)
         return null;
     const a0 = call.arguments[0];
     const a1 = call.arguments[1];
     if (!ts.isIdentifier(a0) || !ts.isSpreadElement(a1) || !ts.isIdentifier(a1.expression))
         return null;
-    if (L.checker.getSymbolAtLocation(a0) !== ctx.eventSym)
+    if (lowerer.checker.getSymbolAtLocation(a0) !== ctx.eventSym)
         return null;
-    if (L.checker.getSymbolAtLocation(a1.expression) !== ctx.restSym)
+    if (lowerer.checker.getSymbolAtLocation(a1.expression) !== ctx.restSym)
         return null;
     const loc = locOf(call);
-    const thisLocal = L.resolveThis();
+    const thisLocal = lowerer.resolveThis();
     if (!thisLocal)
         return null;
     const thisRef = { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc };
     const payload = ctx.tupleParams.map((p) => ({ kind: "varRef", localId: p.id, type: p.type, loc }));
     const anc = emitOverrideAtOrAbove(ctx.info.base);
     if (anc) {
-        ensureEmitSpec(L, anc, ctx.event, ctx.tuple);
+        ensureEmitSpec(lowerer, anc, ctx.event, ctx.tuple);
         const callee = `%${anc.def.name}.emit:${ctx.event}`;
-        L.noteEdge(callee);
-        return { kind: "call", callee, args: [L.upcastTo(thisRef, anc.def.name), ...payload], type: BOOL, loc };
+        lowerer.noteEdge(callee);
+        return { kind: "call", callee, args: [lowerer.upcastTo(thisRef, anc.def.name), ...payload], type: BOOL, loc };
     }
     if (ctx.event === "error") {
         return { kind: "libCall", fn: "emitter.emitError", args: [thisRef, strLit(ctx.event, loc), payload[0]], type: BOOL, loc };
@@ -1054,20 +1052,20 @@ export function emitSpecSuperForward(L, call, access) {
  * with the current method's `this` as the receiver and STATIC dispatch
  * (an emit override at-or-below the lexical class never answers a super
  * call — JS's prototype-chain rule). */
-export function lowerEmitterSuperCall(L, call, access, cls) {
-    const thisLocal = L.resolveThis();
+export function lowerEmitterSuperCall(lowerer, call, access, cls) {
+    const thisLocal = lowerer.resolveThis();
     if (!thisLocal)
         return null;
     const loc = locOf(call);
     const thisRef = { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc };
-    return lowerEmitterMethodCall(L, call, access, cls, { thisRef, cls });
+    return lowerEmitterMethodCall(lowerer, call, access, cls, { thisRef, cls });
 }
 /** One emit site's dispatch: the plain runtime libCall when no override
  * is comparable to the receiver's static class; a direct or virtual
  * specialization call when an override sits at-or-above it; an interned
  * instanceOf-branch helper when overrides exist only strictly below
  * (evaluating receiver and payload exactly once as its arguments). */
-function emitDispatchExpr(L, info, name, tuple, receiver, payload, superOf, loc) {
+function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf, loc) {
     const method = `emit:${name}`;
     const runtime = (recv, args) => name === "error"
         ? { kind: "libCall", fn: "emitter.emitError", args: [recv, strLit(name, loc), args[0]], type: BOOL, loc }
@@ -1077,10 +1075,10 @@ function emitDispatchExpr(L, info, name, tuple, receiver, payload, superOf, loc)
         const anc = emitOverrideAtOrAbove(superOf.base);
         if (!anc)
             return runtime(receiver, payload);
-        ensureEmitSpec(L, anc, name, tuple);
+        ensureEmitSpec(lowerer, anc, name, tuple);
         const callee = `%${anc.def.name}.${method}`;
-        L.noteEdge(callee);
-        return { kind: "call", callee, args: [L.upcastTo(receiver, anc.def.name), ...payload], type: BOOL, loc };
+        lowerer.noteEdge(callee);
+        return { kind: "call", callee, args: [lowerer.upcastTo(receiver, anc.def.name), ...payload], type: BOOL, loc };
     }
     const above = emitOverrideAtOrAbove(info);
     const below = [];
@@ -1091,25 +1089,25 @@ function emitDispatchExpr(L, info, name, tuple, receiver, payload, superOf, loc)
     // gets the event's specialization (descendants intercept via the vtable;
     // the super-forward chain above `above` is ensured as each body lowers).
     if (above)
-        ensureEmitSpec(L, above, name, tuple);
+        ensureEmitSpec(lowerer, above, name, tuple);
     for (const c of below)
-        ensureEmitSpec(L, c, name, tuple);
+        ensureEmitSpec(lowerer, c, name, tuple);
     if (above) {
         if (below.length > 0) {
-            L.noteVirtualEdge(info, method);
+            lowerer.noteVirtualEdge(info, method);
             return { kind: "virtualCall", className: info.def.name, method, args: [receiver, ...payload], type: BOOL, loc };
         }
         const callee = `%${above.def.name}.${method}`;
-        L.noteEdge(callee);
-        return { kind: "call", callee, args: [L.upcastTo(receiver, above.def.name), ...payload], type: BOOL, loc };
+        lowerer.noteEdge(callee);
+        return { kind: "call", callee, args: [lowerer.upcastTo(receiver, above.def.name), ...payload], type: BOOL, loc };
     }
     // Overrides only strictly below: the interned dispatch helper.
     const recvT = receiver.type;
     const key = `emitter.emitDispatch:${typeKey(recvT)}:${name}`;
-    let helper = L.arrHofHelpers.get(key);
+    let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%emitter.emitDispatch.${L.arrHofHelpers.size}`;
-        L.arrHofHelpers.set(key, helper);
+        helper = `%emitter.emitDispatch.${lowerer.arrHofHelpers.size}`;
+        lowerer.arrHofHelpers.set(key, helper);
         const params = [
             { localId: "r.0", name: "r", type: recvT },
             ...tuple.map((t, i) => ({ localId: `a${i}.0`, name: `a${i}`, type: t })),
@@ -1125,12 +1123,12 @@ function emitDispatchExpr(L, info, name, tuple, receiver, payload, superOf, loc)
             collectEmitOverridesBelow(o, oBelow);
             let target;
             if (oBelow.length > 0) {
-                L.noteVirtualEdge(o, method);
+                lowerer.noteVirtualEdge(o, method);
                 target = { kind: "virtualCall", className: o.def.name, method, args: [down, ...argRefs()], type: BOOL, loc };
             }
             else {
                 const callee = `%${o.def.name}.${method}`;
-                L.noteEdge(callee);
+                lowerer.noteEdge(callee);
                 target = { kind: "call", callee, args: [down, ...argRefs()], type: BOOL, loc };
             }
             body.push({
@@ -1142,8 +1140,8 @@ function emitDispatchExpr(L, info, name, tuple, receiver, payload, superOf, loc)
             });
         }
         body.push({ kind: "return", value: runtime(rRef(), argRefs()), loc });
-        L.liftedFns.push({ name: helper, params, returnType: BOOL, locals, body, loc });
+        lowerer.liftedFns.push({ name: helper, params, returnType: BOOL, locals, body, loc });
     }
     return { kind: "call", callee: helper, args: [receiver, ...payload], type: BOOL, loc };
 }
-//# sourceMappingURL=lower-emitter.js.map
+//# sourceMappingURL=lower-event-emitter.js.map