@scriptc/compiler 0.0.34 → 0.0.36

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

@@ -1,12 +1,13 @@
+import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
  * (fields, methods, accessors, overrides), constructor/member lowering with
  * synthesized derived ctors and field initializers, super calls and super
  * accessor access, upcasts, `new` expressions, and the builtin Error
  * hierarchy registration. */
 import * as ts from "../ts7/adapter.js";
-import { BOOL, DATE_T, DYN, F64, bytesOf, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, URL_T, VOID, arrayOf, isSupportedMapKey, isUnitType, typeEquals } from "../../ir/nodes.js";
+import { BOOL, DATE_T, DYN, F64, bytesOf, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, URL_T, VOID, arrayOf, isSupportedMapKey, isUnitType, typeEquals } from "../../ir/ir.js";
 import { MAX_GENERIC_INSTANCES, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, omittedArgFor } from "./lower-calls.js";
-import { isGenericCallableMemberType, typeKey } from "../types.js";
+import { isGenericCallableMemberType, typeKey } from "../type-mapper.js";
 import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf } from "../program.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, newFnCtx, own } from "./lowerer.js";
 import { bufEncoding, lowerMapSeedArrayNew } from "./lower-containers.js";
@@ -14,19 +15,20 @@ import { pureReemittable } from "./lower-exprs.js";
 import { lowerSearchParamsNew } from "./lower-builtins.js";
 import { requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape } from "./lower-stream.js";
-import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall } from "./lower-emitter.js";
+import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall } from "./lower-event-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { uniqueSymbolKeyOf } from "./lower-exprs.js";
 import { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
+import { rejectStaticThis } from "./static-this.js";
 /** The KEY symbol behind a LATE-BOUND (`__@name@id`) property: resolved
    * from the argument of the element-access assignment that declared it
    * (`this[kLimit] = v` — the declaration list holds the BinaryExpression
    * or the ElementAccessExpression itself). Null when no declaration has
    * that shape (well-known-symbol members like `[Symbol.iterator]`). */
-function lateBoundKeySymOf(L, p) {
-    for (const d of L.checker.declarationsOf(p)) {
+function lateBoundKeySymOf(lowerer, p) {
+    for (const d of lowerer.checker.declarationsOf(p)) {
         const access = ts.isBinaryExpression(d) && ts.isElementAccessExpression(d.left)
             ? d.left
             : ts.isElementAccessExpression(d)
@@ -34,7 +36,7 @@ function lateBoundKeySymOf(L, p) {
                 : null;
         if (!access || !ts.isIdentifier(access.argumentExpression))
             continue;
-        const sym = L.resolveValueSymbol(access.argumentExpression);
+        const sym = lowerer.resolveValueSymbol(access.argumentExpression);
         if (sym)
             return sym;
     }
@@ -55,7 +57,7 @@ function lateBoundKeySymOf(L, p) {
    * statically-resolved key declared in symbolFields, and all the slots
    * agree on one IR type. Null when the shape doesn't hold — the value
    * stays checked-dynamic exactly as before. */
-function symbolSlotReturnType(L, fnLike, symbolFields, fields) {
+function symbolSlotReturnType(lowerer, fnLike, symbolFields, fields) {
     if (symbolFields.size === 0)
         return null;
     if (fnLike.type !== undefined || !fnLike.body)
@@ -88,7 +90,7 @@ function symbolSlotReturnType(L, fnLike, symbolFields, fields) {
             return null;
         if (e.expression.kind !== ts.SyntaxKind.ThisKeyword)
             return null;
-        const key = uniqueSymbolKeyOf(L, e.argumentExpression);
+        const key = uniqueSymbolKeyOf(lowerer, e.argumentExpression);
         const fieldName = key ? symbolFields.get(key.sym) : undefined;
         const t = fieldName !== undefined ? fields.get(fieldName) : undefined;
         if (t === undefined || t.kind === "dyn")
@@ -106,10 +108,10 @@ function symbolSlotReturnType(L, fnLike, symbolFields, fields) {
    * toString reach them through dedicated error.* libCall lowerings, and
    * user classes extend them like any base (the emitted subclass struct
    * embeds ScrError's prefix). */
-export function registerBuiltinErrorClasses(L) {
+export function registerBuiltinErrorClasses(lowerer) {
     const loc = { file: "<builtin>", start: 0, end: 0 };
     for (const [irName, rec] of RUNTIME_ERROR_CLASSES) {
-        const base = rec.base ? (L.classes.get(rec.base) ?? null) : null;
+        const base = rec.base ? (lowerer.classes.get(rec.base) ?? null) : null;
         const info = {
             def: {
                 name: irName,
@@ -155,7 +157,7 @@ export function registerBuiltinErrorClasses(L) {
         };
         if (base)
             base.subclasses.push(info);
-        L.classes.set(irName, info);
+        lowerer.classes.set(irName, info);
     }
 }
 /** The runtime-provided node:events EventEmitter as an eagerly-registered
@@ -163,11 +165,11 @@ export function registerBuiltinErrorClasses(L) {
    * the moment an emitter type appears, so the info must exist before any
    * lowering. No decl, no lowerable bodies — `new`/super() reach it
    * through emitter.* libCalls, the method surface lowers through
-   * lower-emitter.ts, and user classes extend it like any base (the
+   * lower-event-emitter.ts, and user classes extend it like any base (the
    * emitted subclass struct embeds ScrEmitter's registry/name prefix —
    * carried by the BACKEND, not by IR fields, so the fields list stays
    * empty and subclass field layout starts right after the prefix). */
-export function registerBuiltinEmitterClass(L) {
+export function registerBuiltinEmitterClass(lowerer) {
     const loc = { file: "<builtin>", start: 0, end: 0 };
     const info = {
         def: { name: RUNTIME_EMITTER_CLASS, runtime: true, fields: [], loc },
@@ -185,7 +187,7 @@ export function registerBuiltinEmitterClass(L) {
         throwingSetters: [],
         staticFields: [],
     };
-    L.classes.set(RUNTIME_EMITTER_CLASS, info);
+    lowerer.classes.set(RUNTIME_EMITTER_CLASS, info);
 }
 /** The runtime-provided node:stream classes as eagerly-registered
    * ClassInfos (the emitter story): mapType names `%Readable` et al the
@@ -195,10 +197,10 @@ export function registerBuiltinEmitterClass(L) {
    * unchanged; the stream method/property surface lowers through
    * lower-stream.ts. No decl, no lowerable bodies, empty field lists —
    * every instance is runtime-allocated (user `extends` is fenced). */
-export function registerBuiltinStreamClasses(L) {
+export function registerBuiltinStreamClasses(lowerer) {
     const loc = { file: "<builtin>", start: 0, end: 0 };
     for (const [irName, rec] of RUNTIME_STREAM_CLASSES) {
-        const base = L.classes.get(rec.base) ?? null;
+        const base = lowerer.classes.get(rec.base) ?? null;
         const info = {
             def: { name: irName, runtime: true, base: rec.base, fields: [], loc },
             fields: new Map(),
@@ -217,7 +219,7 @@ export function registerBuiltinStreamClasses(L) {
         };
         if (base)
             base.subclasses.push(info);
-        L.classes.set(irName, info);
+        lowerer.classes.set(irName, info);
     }
 }
 /** The stream ClassInfo a VALUE symbol refers to (`new Readable(...)`,
@@ -227,27 +229,27 @@ export function registerBuiltinStreamClasses(L) {
    * also types child stdio — under @types/node the childStream mapping
    * keeps priority and the static stream classes stand down; the shipped
    * fallback declarations are the supported surface). */
-export function builtinStreamInfoOf(L, symbol) {
+export function builtinStreamInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
-    if (!L.isStdlibSymbol(symbol)) {
+    if (!lowerer.isStdlibSymbol(symbol)) {
         // A const ALIAS of a namespace member (`const Writable =
         // stream.Writable` — the two-step spelling; the one-step
         // require('stream').Writable rides the same walk): follow the
         // member to the stdlib class symbol. The declaration itself is
         // alias plumbing (streamClassAliasDecl — both declaration walks
         // skip it).
-        const decl = L.checker.valueDeclarationOf(symbol);
+        const decl = lowerer.checker.valueDeclarationOf(symbol);
         if (decl && ts.isVariableDeclaration(decl) &&
             (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
             !decl.initializer.questionDotToken &&
-            L.builtinNamespaceModuleOf(decl.initializer.expression) === "stream") {
-            const mSym = L.checker.getSymbolAtLocation(decl.initializer.name);
-            const target = mSym && mSym.flags & ts.SymbolFlags.Alias ? L.checker.getAliasedSymbol(mSym) : mSym;
+            lowerer.builtinNamespaceModuleOf(decl.initializer.expression) === "stream") {
+            const mSym = lowerer.checker.getSymbolAtLocation(decl.initializer.name);
+            const target = mSym && mSym.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(mSym) : mSym;
             if (target && target !== symbol)
-                return builtinStreamInfoOf(L, target);
+                return builtinStreamInfoOf(lowerer, target);
         }
         return null;
     }
@@ -258,7 +260,7 @@ export function builtinStreamInfoOf(L, symbol) {
     }
     if (!irName)
         return null;
-    const declared = L.checker.declarationsOf(symbol).some((d) => {
+    const declared = lowerer.checker.declarationsOf(symbol).some((d) => {
         if (!ts.isClassDeclaration(d))
             return false;
         if (isNodeTypesPath(d.getSourceFile().fileName))
@@ -272,7 +274,7 @@ export function builtinStreamInfoOf(L, symbol) {
         }
         return false;
     });
-    return declared ? (L.classes.get(irName) ?? null) : null;
+    return declared ? (lowerer.classes.get(irName) ?? null) : null;
 }
 /** The undefined-armed union of a JS class property's inferred type — the
    * honest slot for a field first assigned outside the constructor's top
@@ -280,13 +282,13 @@ export function builtinStreamInfoOf(L, symbol) {
    * inference is unmappable, checked-dynamic (dyn stays out of class
    * fields — KEEP NARROW), or an arm-less kind that cannot join a union
    * (genResultRecord's list, including scalar-backed Date values). */
-function undefArmedFieldType(L, p) {
-    const t = L.checker.getTypeOfSymbol(p);
-    const mapped = L.mapTypeOf(t);
+function undefArmedFieldType(lowerer, p) {
+    const t = lowerer.checker.getTypeOfSymbol(p);
+    const mapped = lowerer.mapTypeOf(t);
     if (!mapped || mapped.kind === "void" || mapped.kind === "dyn")
         return null;
     const byKey = new Map();
-    const arms = mapped.kind === "union" ? (L.unions.get(mapped.unionId)?.arms ?? []) : [mapped];
+    const arms = mapped.kind === "union" ? (lowerer.unions.get(mapped.unionId)?.arms ?? []) : [mapped];
     for (const a of arms) {
         if (a.kind === "map" || a.kind === "regex" || a.kind === "date" ||
             a.kind === "jsval" || a.kind === "generator") {
@@ -296,38 +298,38 @@ function undefArmedFieldType(L, p) {
     }
     byKey.set(typeKey(UNDEFINED_T), UNDEFINED_T);
     const sorted = [...byKey.values()].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) };
 }
 /** The emitter ClassInfo a VALUE symbol refers to (`new EventEmitter`,
    * `extends EventEmitter`, `x instanceof EventEmitter`) — any import
    * spelling (named/default/namespace member, CJS require) resolves to
    * the ambient class. Provenance-checked like the error classes: only a
    * stdlib-file declaration inside the "events" ambient module counts. */
-export function builtinEmitterInfoOf(L, symbol) {
+export function builtinEmitterInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
-    if (!L.isStdlibSymbol(symbol)) {
+    if (!lowerer.isStdlibSymbol(symbol)) {
         // A const ALIAS of the emitter class member (`const EventEmitter =
         // require('node:events').EventEmitter` — commander's spelling; the
         // two-step `const EE = events.EventEmitter` rides the same walk):
         // follow the member off the module namespace. The declaration
         // itself is alias plumbing (builtinMemberRequireDecl — both
         // declaration walks skip it).
-        const decl = L.checker.valueDeclarationOf(symbol);
+        const decl = lowerer.checker.valueDeclarationOf(symbol);
         if (decl !== undefined && ts.isVariableDeclaration(decl) &&
             (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
             decl.initializer !== undefined &&
             ts.isPropertyAccessExpression(decl.initializer) &&
             !decl.initializer.questionDotToken &&
             decl.initializer.name.text === "EventEmitter" &&
-            L.builtinNamespaceModuleOf(decl.initializer.expression) === "events") {
-            return L.classes.get(RUNTIME_EMITTER_CLASS) ?? null;
+            lowerer.builtinNamespaceModuleOf(decl.initializer.expression) === "events") {
+            return lowerer.classes.get(RUNTIME_EMITTER_CLASS) ?? null;
         }
         return null;
     }
     if (symbol.name !== "EventEmitter")
         return null;
-    const declared = L.checker.declarationsOf(symbol).some((d) => {
+    const declared = lowerer.checker.declarationsOf(symbol).some((d) => {
         if (!ts.isClassDeclaration(d) && !ts.isInterfaceDeclaration(d))
             return false;
         let node = d.parent;
@@ -339,24 +341,24 @@ export function builtinEmitterInfoOf(L, symbol) {
         }
         return false;
     });
-    return declared ? (L.classes.get(RUNTIME_EMITTER_CLASS) ?? null) : null;
+    return declared ? (lowerer.classes.get(RUNTIME_EMITTER_CLASS) ?? null) : null;
 }
 /** The builtin error ClassInfo a VALUE symbol refers to (`new Error`,
    * `extends TypeError`, `x instanceof RangeError`), or null. Provenance-
    * checked: only the standard library's declarations count — a user's own
    * `class Error` resolves through classBySymbol instead. */
-export function builtinErrorInfoOf(L, symbol) {
-    if (!symbol || !L.isStdlibSymbol(symbol))
+export function builtinErrorInfoOf(lowerer, symbol) {
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
     for (const [irName, rec] of RUNTIME_ERROR_CLASSES) {
         if (rec.lib === symbol.name)
-            return L.classes.get(irName) ?? null;
+            return lowerer.classes.get(irName) ?? null;
     }
     return null;
 }
 /** The instance-method surface the runtime EventEmitter owns — subclass
  * members with these names are fenced (collectClassShapeInner) and calls
- * to them on emitter-rooted receivers lower through lower-emitter.ts. */
+ * to them on emitter-rooted receivers lower through lower-event-emitter.ts. */
 export const EMITTER_API_MEMBERS = new Set([
     "on", "addListener", "once", "prependListener", "prependOnceListener",
     "off", "removeListener", "removeAllListeners", "emit", "listenerCount",
@@ -374,18 +376,18 @@ export function decoratorNodesOf(n) {
    * `@dec(...)` evaluates the CALLEE before any argument — and property
    * chains throw at their ROOT (`@instance.decorate` reads `instance`
    * first). */
-export function ambientDecoratorThrowNameOf(L, dExpr) {
+function ambientDecoratorThrowNameOf(lowerer, dExpr) {
     let e = dExpr;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
     const target = ts.isCallExpression(e) ? e.expression : e;
-    const root = ambientUndefVarRootOf(L, target);
+    const root = ambientUndefVarRootOf(lowerer, target);
     if (root)
         return root.text;
     let callee = target;
     while (ts.isParenthesizedExpression(callee))
         callee = callee.expression;
-    if (ts.isIdentifier(callee) && ambientUndefinedFnSymbolOf(L, callee) !== null)
+    if (ts.isIdentifier(callee) && ambientUndefinedFnSymbolOf(lowerer, callee) !== null)
         return callee.text;
     return null;
 }
@@ -400,7 +402,7 @@ export function ambientDecoratorThrowNameOf(L, dExpr) {
    * computed keys. Anything richer (factory calls over defined values,
    * property-access reads, computed-key calls) stops the proof — the
    * named fences answer instead. */
-export function guaranteedDecorationThrow(L, decl) {
+export function guaranteedDecorationThrow(lowerer, decl) {
     const stripParens = (e) => {
         let x = e;
         while (ts.isParenthesizedExpression(x))
@@ -408,7 +410,7 @@ export function guaranteedDecorationThrow(L, decl) {
         return x;
     };
     const decoratorVerdict = (d) => {
-        const name = ambientDecoratorThrowNameOf(L, d.expression);
+        const name = ambientDecoratorThrowNameOf(lowerer, d.expression);
         if (name !== null)
             return { name, node: d };
         const e = stripParens(d.expression);
@@ -450,12 +452,12 @@ export function guaranteedDecorationThrow(L, decl) {
     }
     return null;
 }
-export function collectClassShape(L, decl) {
-    const symbol = L.collectDeferring(() => declSymbolOf(L, decl), () => L.collectClassShapeInner(decl));
+export function collectClassShape(lowerer, decl) {
+    const symbol = lowerer.collectDeferring(() => declSymbolOf(lowerer, decl), () => lowerer.collectClassShapeInner(decl));
     // Typed receivers and module retention know the class only by its
     // qualified IR name — index the deferral under it too.
     if (symbol)
-        L.deferredClassByName.set(L.classNamer(decl), symbol);
+        lowerer.deferredClassByName.set(lowerer.classNamer(decl), symbol);
     // A poisoned class containing a static BLOCK or a DECORATOR must report
     // EAGERLY: deferral's premise ("an unreached broken declaration costs
     // nothing") fails here — Node runs the block (and calls the decorator)
@@ -465,13 +467,13 @@ export function collectClassShape(L, decl) {
     const hasDeclTimeCode = (n) => ts.isClassStaticBlockDeclaration(n) ||
         (n.modifiers ?? []).some((m) => m.kind === ts.SyntaxKind.Decorator);
     if (symbol && (hasDeclTimeCode(decl) || decl.members.some(hasDeclTimeCode))) {
-        const diags = L.deferredDiags.get(symbol);
+        const diags = lowerer.deferredDiags.get(symbol);
         if (diags) {
-            L.deferredDiags.delete(symbol);
-            if (!L.alreadyFlushed.has(symbol)) {
-                L.flushedSymbols.add(symbol);
+            lowerer.deferredDiags.delete(symbol);
+            if (!lowerer.alreadyFlushed.has(symbol)) {
+                lowerer.flushedSymbols.add(symbol);
                 for (const d of diags)
-                    L.pushDiag(d);
+                    lowerer.pushDiag(d);
             }
         }
     }
@@ -490,19 +492,19 @@ export function collectClassShape(L, decl) {
             ?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword)
             ?.types.map((t) => t.expression)
             .filter(ts.isIdentifier)[0];
-        const baseSym = baseIdent ? L.resolveValueSymbol(baseIdent) : null;
-        const baseDiags = baseSym ? L.deferredDiags.get(baseSym) : undefined;
+        const baseSym = baseIdent ? lowerer.resolveValueSymbol(baseIdent) : null;
+        const baseDiags = baseSym ? lowerer.deferredDiags.get(baseSym) : undefined;
         if (baseSym && baseDiags) {
-            L.deferredDiags.delete(baseSym);
-            if (!L.alreadyFlushed.has(baseSym)) {
-                L.flushedSymbols.add(baseSym);
+            lowerer.deferredDiags.delete(baseSym);
+            if (!lowerer.alreadyFlushed.has(baseSym)) {
+                lowerer.flushedSymbols.add(baseSym);
                 for (const d of baseDiags)
-                    L.pushDiag(d);
+                    lowerer.pushDiag(d);
             }
         }
     }
 }
-export function collectClassShapeInner(L, decl, jsNameOverride, inst, 
+export function collectClassShapeInner(lowerer, decl, jsNameOverride, inst, 
 /** MIXIN instantiation mode (lower-mixins.ts): the class inside a
  * mixin function, collected per call site — `base` is the ARGUMENT
  * class (the heritage clause names the mixin's parameter and is
@@ -515,8 +517,8 @@ mixin) {
         // nameless class DECLARATION is `export default class {}` — its
         // symbol is the module's default export (declSymbolOf) and it
         // registers under classNamer's "%anon" spelling (unique per file).
-        if (!decl.name && ts.isClassDeclaration(decl) && declSymbolOf(L, decl) === undefined) {
-            L.unsupported("SC1090", decl, "anonymous classes");
+        if (!decl.name && ts.isClassDeclaration(decl) && declSymbolOf(lowerer, decl) === undefined) {
+            lowerer.unsupported("SC1090", decl, "anonymous classes");
         }
         // Decorators are declaration-time CALLS (they run when the class
         // statement evaluates and may replace the declaration outright).
@@ -542,16 +544,16 @@ mixin) {
                 // loaders leave `@dec` in place) — there is no runtime behavior
                 // to be exact against.
                 if (isJsSourceFile(decl.getSourceFile())) {
-                    L.unsupported("SC1090", (classDecoratorNodes[0] ?? decoratorNodesOf(decoratedMembers[0])[0]), "decorators in JavaScript sources (V8 has not shipped decorators — Node cannot execute this file)");
+                    lowerer.unsupported("SC1090", (classDecoratorNodes[0] ?? decoratorNodesOf(decoratedMembers[0])[0]), "decorators in JavaScript sources (V8 has not shipped decorators — Node cannot execute this file)");
                 }
                 // The guaranteed-throw SHELL: declarations only (expressions
                 // lower their throw at the expression — lowerClassExpression),
                 // never instantiations/mixins (they share a family declaration).
                 if (inst === undefined && mixin === undefined &&
                     ts.isClassDeclaration(decl) && decl.typeParameters === undefined) {
-                    const thrown = guaranteedDecorationThrow(L, decl);
+                    const thrown = guaranteedDecorationThrow(lowerer, decl);
                     if (thrown) {
-                        const className = L.classNamer(decl);
+                        const className = lowerer.classNamer(decl);
                         const info = {
                             def: {
                                 name: className,
@@ -578,12 +580,12 @@ mixin) {
                                 shapes: [{ kind: "ambientThrow", name: thrown.name }],
                             },
                         };
-                        L.classes.set(className, info);
+                        lowerer.classes.set(className, info);
                         const classSymbol = decl.name
-                            ? L.checker.getSymbolAtLocation(decl.name)
-                            : declSymbolOf(L, decl);
+                            ? lowerer.checker.getSymbolAtLocation(decl.name)
+                            : declSymbolOf(lowerer, decl);
                         if (classSymbol)
-                            L.classBySymbol.set(classSymbol, info);
+                            lowerer.classBySymbol.set(classSymbol, info);
                         return;
                     }
                 }
@@ -598,7 +600,7 @@ mixin) {
                                     ? "auto-accessor decorators"
                                     : "field decorators")
                                 : "member decorators";
-                    L.unsupported("SC1090", dec, `${kind} (the standard context object and member replacement have no static lowering — class decorators and provably-throwing ambient decorations compile)`);
+                    lowerer.unsupported("SC1090", dec, `${kind} (the standard context object and member replacement have no static lowering — class decorators and provably-throwing ambient decorations compile)`);
                 }
             }
             if (classDecoratorNodes.length > 0) {
@@ -606,14 +608,14 @@ mixin) {
                 // minted class; only once-evaluated declarations have a single
                 // decoration event to lower.
                 if (!ts.isClassDeclaration(decl)) {
-                    L.unsupported("SC1090", classDecoratorNodes[0], "decorators on class expressions (each evaluation decorates a distinct class)");
+                    lowerer.unsupported("SC1090", classDecoratorNodes[0], "decorators on class expressions (each evaluation decorates a distinct class)");
                 }
                 // A generic class declares ONCE in JS (one decoration event over
                 // the one runtime Box) but compiles per instantiation here — the
                 // family object is never constructed and the instantiations were
                 // never individually decorated.
                 if (decl.typeParameters !== undefined) {
-                    L.unsupported("SC1090", classDecoratorNodes[0], "decorators on generic classes (JS decorates the one runtime class; the compiled family instantiates per type argument)");
+                    lowerer.unsupported("SC1090", classDecoratorNodes[0], "decorators on generic classes (JS decorates the one runtime class; the compiled family instantiates per type argument)");
                 }
             }
         }
@@ -629,9 +631,9 @@ mixin) {
         // FAMILY of classes has no once-evaluated story.
         const familyMode = decl.typeParameters !== undefined && inst === undefined;
         if (familyMode && !ts.isClassDeclaration(decl)) {
-            L.unsupported("SC1090", decl, "generic class expressions");
+            lowerer.unsupported("SC1090", decl, "generic class expressions");
         }
-        const className = inst ? inst.name : mixin ? mixin.name : L.classNamer(decl); // program-wide qualified name
+        const className = inst ? inst.name : mixin ? mixin.name : lowerer.classNamer(decl); // program-wide qualified name
         // Single inheritance: `extends` of a class declared in the program.
         // tsc guarantees the base is declared before the derived class (its
         // use-before-declaration error), and collection runs in module order,
@@ -646,7 +648,7 @@ mixin) {
         if (familyMode && decl.heritageClauses !== undefined) {
             const tpSyms = new Set();
             for (const tp of decl.typeParameters) {
-                const s = L.checker.getSymbolAtLocation(tp.name);
+                const s = lowerer.checker.getSymbolAtLocation(tp.name);
                 if (s)
                     tpSyms.add(s);
             }
@@ -656,7 +658,7 @@ mixin) {
                 for (const t of clause.types) {
                     let mentions = false;
                     ts.walkPreorder(t, (n) => {
-                        const s = ts.isIdentifier(n) ? L.checker.getSymbolAtLocation(n) : undefined;
+                        const s = ts.isIdentifier(n) ? lowerer.checker.getSymbolAtLocation(n) : undefined;
                         if (s && tpSyms.has(s)) {
                             mentions = true;
                             return "stop";
@@ -664,7 +666,7 @@ mixin) {
                         return undefined;
                     });
                     if (mentions) {
-                        L.unsupported("SC1090", t, "generic classes whose 'extends' clause mentions their own type parameters (each instantiation would need a different base)");
+                        lowerer.unsupported("SC1090", t, "generic classes whose 'extends' clause mentions their own type parameters (each instantiation would need a different base)");
                     }
                 }
             }
@@ -680,15 +682,15 @@ mixin) {
             // `extends events.EventEmitter` — the namespace-member spelling of
             // the ambient emitter base resolves like the named import.
             if (t && ts.isPropertyAccessExpression(t.expression) && ts.isIdentifier(t.expression.name)) {
-                const memberSym = L.checker.getSymbolAtLocation(t.expression.name);
+                const memberSym = lowerer.checker.getSymbolAtLocation(t.expression.name);
                 const resolved = memberSym && memberSym.flags & ts.SymbolFlags.Alias
-                    ? L.checker.getAliasedSymbol(memberSym)
+                    ? lowerer.checker.getAliasedSymbol(memberSym)
                     : memberSym;
-                const emitterBase = L.builtinEmitterInfoOf(resolved);
-                const streamBaseNs = builtinStreamInfoOf(L, resolved);
+                const emitterBase = lowerer.builtinEmitterInfoOf(resolved);
+                const streamBaseNs = builtinStreamInfoOf(lowerer, resolved);
                 if (emitterBase || streamBaseNs) {
                     if (t.typeArguments)
-                        L.unsupported("SC1090", t, "extending generic classes");
+                        lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = (emitterBase ?? streamBaseNs);
                     continue;
                 }
@@ -697,14 +699,14 @@ mixin) {
                 // (import= alias chains included), with the source-order guard
                 // (the class statement evaluates at its init position; a base
                 // block below it would still be uninitialized in Node).
-                if (!t.expression.questionDotToken && nsMemberIdentOf(L, t.expression)) {
+                if (!t.expression.questionDotToken && nsMemberIdentOf(lowerer, t.expression)) {
                     if (t.typeArguments)
-                        L.unsupported("SC1090", t, "extending generic classes");
+                        lowerer.unsupported("SC1090", t, "extending generic classes");
                     if (memberSym)
-                        fenceEarlyNsMemberRef(L, t.expression, memberSym);
-                    const nsBase = resolved ? L.classBySymbol.get(resolved) : undefined;
+                        fenceEarlyNsMemberRef(lowerer, t.expression, memberSym);
+                    const nsBase = resolved ? lowerer.classBySymbol.get(resolved) : undefined;
                     if (!nsBase) {
-                        L.unsupported("SC1090", t, `extending the namespace member '${t.expression.name.text}' (no class lowering)`);
+                        lowerer.unsupported("SC1090", t, `extending the namespace member '${t.expression.name.text}' (no class lowering)`);
                     }
                     base = nsBase;
                     continue;
@@ -721,15 +723,15 @@ mixin) {
                 // answers null for them) and keep the computed-expression fence:
                 // the runtime base is whichever assignment ran last.
                 if (!t.expression.questionDotToken) {
-                    const propBase = propertyAssignedClassInfoOf(L, memberSym);
+                    const propBase = propertyAssignedClassInfoOf(lowerer, memberSym);
                     if (propBase) {
                         if (t.typeArguments)
-                            L.unsupported("SC1090", t, "extending generic classes");
+                            lowerer.unsupported("SC1090", t, "extending generic classes");
                         const baseDecl = propBase.decl;
                         if (baseDecl != null &&
                             baseDecl.getSourceFile() === decl.getSourceFile() &&
                             baseDecl.getStart() > decl.getStart()) {
-                            L.unsupported("SC1090", t, `extending '${t.expression.getText()}' above the statement that assigns it (the property is still undefined when this class evaluates — Node throws here; assign the base first)`);
+                            lowerer.unsupported("SC1090", t, `extending '${t.expression.getText()}' above the statement that assigns it (the property is still undefined when this class evaluates — Node throws here; assign the base first)`);
                         }
                         base = propBase;
                         continue;
@@ -738,12 +740,12 @@ mixin) {
                     // fence (the generic computed-expression one below would hide
                     // what actually blocks it).
                     const rebinds = memberSym !== undefined &&
-                        L.checker
+                        lowerer.checker
                             .declarationsOf(memberSym)
                             .filter((d) => ts.isBinaryExpression(d) &&
                             d.operatorToken.kind === ts.SyntaxKind.EqualsToken).length > 1;
                     if (rebinds) {
-                        L.unsupported("SC1090", t, `extending the reassigned property '${t.expression.getText()}' (the runtime base is whichever assignment ran last — bind the class exactly once)`);
+                        lowerer.unsupported("SC1090", t, `extending the reassigned property '${t.expression.getText()}' (the runtime base is whichever assignment ran last — bind the class exactly once)`);
                     }
                 }
             }
@@ -753,8 +755,8 @@ mixin) {
             // recursion order delivers exactly that).
             if (t && ts.isClassExpression(t.expression)) {
                 if (t.typeArguments)
-                    L.unsupported("SC1090", t, "extending generic classes");
-                const baseExpr = L.lowerClassExpressionInfo(t.expression);
+                    lowerer.unsupported("SC1090", t, "extending generic classes");
+                const baseExpr = lowerer.lowerClassExpressionInfo(t.expression);
                 base = baseExpr;
                 continue;
             }
@@ -765,16 +767,16 @@ mixin) {
             // callee is NOT a mixin function keeps the computed-expression
             // fence below.
             if (t && ts.isCallExpression(t.expression) && !t.typeArguments) {
-                const mixinBase = L.mixinCallClassInfoOf(t.expression);
+                const mixinBase = lowerer.mixinCallClassInfoOf(t.expression);
                 if (mixinBase) {
                     base = mixinBase;
                     continue;
                 }
             }
             if (!t || !ts.isIdentifier(t.expression)) {
-                L.unsupported("SC1090", clause, "extending computed expressions");
+                lowerer.unsupported("SC1090", clause, "extending computed expressions");
             }
-            const symbol = L.resolveValueSymbol(t.expression);
+            const symbol = lowerer.resolveValueSymbol(t.expression);
             // Extending a REBINDABLE decorated class (analysis already ran —
             // this collection is a class expression or a generic
             // instantiation demanded during lowering): the runtime base is
@@ -782,53 +784,53 @@ mixin) {
             // subclasses collected BEFORE analysis meet the same fence from
             // analyzeClassDecoration's subclasses check.
             {
-                const directBase = symbol && L.classBySymbol.get(symbol);
+                const directBase = symbol && lowerer.classBySymbol.get(symbol);
                 if (directBase && directBase.classDecorators?.valueGlobalId !== undefined) {
-                    L.unsupported("SC1090", t, `extending the decorated class '${directBase.def.jsName ?? directBase.def.name}' (its decorators may replace it — the runtime base would be the decoration result)`);
+                    lowerer.unsupported("SC1090", t, `extending the decorated class '${directBase.def.jsName ?? directBase.def.name}' (its decorators may replace it — the runtime base would be the decoration result)`);
                 }
                 if (directBase)
-                    fenceDecorationThrows(L, directBase, t);
+                    fenceDecorationThrows(lowerer, directBase, t);
             }
             // `extends DOMException`: the runtime instance carries hidden
             // slots (the legacy code, the cause) BEYOND the ScrError prefix
             // the IR fields describe — a subclass layout would overlap them.
-            if (L.builtinErrorInfoOf(symbol)?.def.name === "%DOMException") {
-                L.unsupported("SC1090", t, "extending DOMException (its runtime layout carries hidden slots a subclass would overlap — extend Error and set name/code yourself)");
+            if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%DOMException") {
+                lowerer.unsupported("SC1090", t, "extending DOMException (its runtime layout carries hidden slots a subclass would overlap — extend Error and set name/code yourself)");
             }
-            const named = (symbol && L.classBySymbol.get(symbol)) ?? L.builtinErrorInfoOf(symbol) ??
-                L.builtinEmitterInfoOf(symbol) ?? builtinStreamInfoOf(L, symbol) ??
+            const named = (symbol && lowerer.classBySymbol.get(symbol)) ?? lowerer.builtinErrorInfoOf(symbol) ??
+                lowerer.builtinEmitterInfoOf(symbol) ?? builtinStreamInfoOf(lowerer, symbol) ??
                 // A const BINDING holding exactly one class (`const B = Animal`,
                 // `const B = class {…}`): the base is that class — extends
                 // through the alias is the declaration story (a general class
                 // VALUE stays fenced: the runtime base would be dynamic).
-                exactClassOfReceiver(L, t.expression) ??
+                exactClassOfReceiver(lowerer, t.expression) ??
                 // A require BINDING of a class-expression whole export
                 // (`const C = require('./x')` over `module.exports = class {…}`):
                 // the alias resolves to the expression's own symbol — the same
                 // declaration story, collected on demand.
-                propertyAssignedClassInfoOf(L, symbol) ??
+                propertyAssignedClassInfoOf(lowerer, symbol) ??
                 // A const BINDING of a mixin call (`const Tagged = M(Base);
                 // class D extends Tagged {}`): the binding pins that call's
                 // instantiation — collected on demand (lower-mixins.ts).
-                mixinResultBindingClassOf(L, symbol) ?? null;
+                mixinResultBindingClassOf(lowerer, symbol) ?? null;
             // `extends Box<number>` — a GENERIC program class as the base: the
             // base is the concrete INSTANTIATION, resolved through the heritage
             // type (mapType registers/reuses `Box%0`).
             if (named?.generic) {
-                const instT = L.checker.getTypeAtLocation(t);
-                const mappedBase = L.mapTypeOf(instT);
-                const instBase = mappedBase?.kind === "object" ? L.classes.get(mappedBase.className) : undefined;
+                const instT = lowerer.checker.getTypeAtLocation(t);
+                const mappedBase = lowerer.mapTypeOf(instT);
+                const instBase = mappedBase?.kind === "object" ? lowerer.classes.get(mappedBase.className) : undefined;
                 if (!instBase || instBase.generic) {
-                    L.unsupported("SC1090", t, `extending the generic class '${t.expression.text}' without a compiled concrete instantiation (the type arguments must map — see the instantiation's own diagnostic)`);
+                    lowerer.unsupported("SC1090", t, `extending the generic class '${t.expression.text}' without a compiled concrete instantiation (the type arguments must map — see the instantiation's own diagnostic)`);
                 }
                 base = instBase;
                 continue;
             }
             if (t.typeArguments)
-                L.unsupported("SC1090", t, "extending generic classes");
+                lowerer.unsupported("SC1090", t, "extending generic classes");
             base = named;
             if (!base) {
-                L.unsupported("SC1090", t, `extending classes not declared in the program ('${t.expression.text}')`);
+                lowerer.unsupported("SC1090", t, `extending classes not declared in the program ('${t.expression.text}')`);
             }
         }
         const fields = new Map(base ? base.fields : []);
@@ -881,21 +883,21 @@ mixin) {
                 ? genericFieldFnNodeOf(member)
                 : member;
             if (!ts.isIdentifier(member.name) && !ts.isPrivateIdentifier(member.name)) {
-                L.unsupported("SC1090", member, "computed generic method names");
+                lowerer.unsupported("SC1090", member, "computed generic method names");
             }
             if (fnNode.asteriskToken)
-                L.unsupported("SC1071", member);
+                lowerer.unsupported("SC1071", member);
             const mName = member.name.text;
             const typeParams = [];
             for (const tp of fnNode.typeParameters) {
-                const sym = L.checker.getSymbolAtLocation(tp.name);
+                const sym = lowerer.checker.getSymbolAtLocation(tp.name);
                 if (!sym)
-                    L.unsupported("SC1090", member, "this method form");
+                    lowerer.unsupported("SC1090", member, "this method form");
                 typeParams.push(sym);
             }
             for (const param of fnNode.parameters) {
                 if (!ts.isIdentifier(param.name) && !ts.isObjectBindingPattern(param.name) && !ts.isArrayBindingPattern(param.name)) {
-                    L.unsupported("SC1031", param);
+                    lowerer.unsupported("SC1031", param);
                 }
             }
             (isStatic ? genericStatics : genericMethods).set(mName, {
@@ -921,19 +923,7 @@ mixin) {
                 // with arrow functions transparent (they inherit the block's
                 // `this`) and this-binding function forms opaque (their `this` is
                 // their own).
-                const checkThis = (n) => {
-                    if (ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n) ||
-                        ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n) ||
-                        ts.isGetAccessor(n) || ts.isSetAccessor(n) ||
-                        ts.isClassDeclaration(n) || ts.isClassExpression(n)) {
-                        return;
-                    }
-                    if (n.kind === ts.SyntaxKind.ThisKeyword || n.kind === ts.SyntaxKind.SuperKeyword) {
-                        L.unsupported("SC1090", n, "'this' in class static blocks (it names the class — reference the class by name instead)");
-                    }
-                    n.forEachChild(checkThis);
-                };
-                member.body.forEachChild(checkThis);
+                rejectStaticThis(lowerer, member.body, () => "'this' in class static blocks (it names the class — reference the class by name instead)");
                 staticBlocks.push(member);
                 continue;
             }
@@ -965,17 +955,17 @@ mixin) {
                     (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) &&
                     member.initializer &&
                     member.postfixToken?.kind !== ts.SyntaxKind.QuestionToken) {
-                    const type = L.irTypeOf(member.name);
+                    const type = lowerer.irTypeOf(member.name);
                     if (type.kind === "void")
-                        L.badType(member.name, L.typeOf(member.name));
+                        lowerer.badType(member.name, lowerer.typeOf(member.name));
                     if (type.kind === "dyn") {
-                        L.unsupported("SC1090", member.name, "'unknown'-typed static fields");
+                        lowerer.unsupported("SC1090", member.name, "'unknown'-typed static fields");
                     }
                     staticFields.push({
                         name: member.name.text,
                         type,
                         initializer: member.initializer,
-                        globalId: `%g.s.${L.classNamer(decl)}.${member.name.text}`,
+                        globalId: `%g.s.${lowerer.classNamer(decl)}.${member.name.text}`,
                         readonly: modifiers.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword),
                     });
                 }
@@ -987,7 +977,7 @@ mixin) {
                     member.body &&
                     member.typeParameters === undefined &&
                     member.asteriskToken === undefined) {
-                    const { shapes, funcType: ft } = L.lambdaSignature(member);
+                    const { shapes, funcType: ft } = lowerer.lambdaSignature(member);
                     staticMethods.set(member.name.text, { params: shapes, ret: ft.ret, member });
                 }
                 // GENERIC static methods monomorphize like top-level generic
@@ -1033,11 +1023,11 @@ mixin) {
                 const pname = memberName.text;
                 if (base !== null &&
                     (base.fields.has(pname) ||
-                        L.findMethodOn(base, pname) !== null ||
-                        L.findMethodOn(base, `get:${pname}`) !== null ||
-                        L.findMethodOn(base, `set:${pname}`) !== null ||
-                        findGenericMethodOn(L, base, pname) !== null)) {
-                    L.unsupported("SC1090", memberName, `redeclaring the private name '${pname}' of a base class (JS gives each class its own distinct '${pname}' slot; these layouts have one slot per name — rename one)`);
+                        lowerer.findMethodOn(base, pname) !== null ||
+                        lowerer.findMethodOn(base, `get:${pname}`) !== null ||
+                        lowerer.findMethodOn(base, `set:${pname}`) !== null ||
+                        findGenericMethodOn(lowerer, base, pname) !== null)) {
+                    lowerer.unsupported("SC1090", memberName, `redeclaring the private name '${pname}' of a base class (JS gives each class its own distinct '${pname}' slot; these layouts have one slot per name — rename one)`);
                 }
             }
             // The EventEmitter API surface is runtime-provided: a subclass
@@ -1046,7 +1036,7 @@ mixin) {
             // override is fenced rather than silently split-brained — with ONE
             // exception: `emit` in the forwarding shape on a plain (non-
             // stream) emitter-rooted class monomorphizes per event name
-            // (lower-emitter.ts's emit-overrides block). Stream-rooted classes
+            // (lower-event-emitter.ts's emit-overrides block). Stream-rooted classes
             // keep the fence for emit too: the runtime stream machinery emits
             // 'data'/'end'/... internally, which could never route through
             // the override.
@@ -1067,18 +1057,18 @@ mixin) {
                 if (memberName.text === "emit" && !streamRooted && !inst && !mixin &&
                     ts.isMethodDeclaration(member) &&
                     !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
-                    const reason = emitOverrideShapeReason(L, member);
+                    const reason = emitOverrideShapeReason(lowerer, member);
                     if (reason === null) {
-                        const eventSym = L.checker.getSymbolAtLocation(member.parameters[0].name);
-                        const restSym = L.checker.getSymbolAtLocation(member.parameters[1].name);
+                        const eventSym = lowerer.checker.getSymbolAtLocation(member.parameters[0].name);
+                        const restSym = lowerer.checker.getSymbolAtLocation(member.parameters[1].name);
                         if (eventSym && restSym) {
                             emitOverride = { decl: member, eventSym, restSym };
                             continue;
                         }
                     }
-                    L.unsupported("SC1090", memberName, `overriding EventEmitter's 'emit' outside the forwarding shape (${reason ?? "its parameters do not resolve statically"}; the compiled form is \`emit(event: string, ...args: unknown[]): boolean\`)`);
+                    lowerer.unsupported("SC1090", memberName, `overriding EventEmitter's 'emit' outside the forwarding shape (${reason ?? "its parameters do not resolve statically"}; the compiled form is \`emit(event: string, ...args: unknown[]): boolean\`)`);
                 }
-                L.unsupported("SC1090", memberName, `overriding the EventEmitter member '${memberName.text}' (the runtime owns the emitter surface)`);
+                lowerer.unsupported("SC1090", memberName, `overriding the EventEmitter member '${memberName.text}' (the runtime owns the emitter surface)`);
             }
             // The stream surface is likewise runtime-provided on stream-rooted
             // subclasses: API members (push/read/write/...) and the property
@@ -1098,15 +1088,15 @@ mixin) {
                 if (streamBase) {
                     const name = memberName.text;
                     if (STREAM_API_MEMBERS.has(name) || STREAM_PROP_MEMBERS.has(name)) {
-                        L.unsupported("SC1090", memberName, `overriding the stream member '${name}' (the runtime owns the stream surface)`);
+                        lowerer.unsupported("SC1090", memberName, `overriding the stream member '${name}' (the runtime owns the stream surface)`);
                     }
                     if (name === "_writev" || name === "_construct") {
-                        L.unsupported("SC1090", memberName, `declaring '${name}' on a stream subclass (${name === "_writev" ? "batched writes are" : "deferred construction is"} not lowered — writes deliver one chunk at a time)`);
+                        lowerer.unsupported("SC1090", memberName, `declaring '${name}' on a stream subclass (${name === "_writev" ? "batched writes are" : "deferred construction is"} not lowered — writes deliver one chunk at a time)`);
                     }
                     const accepted = streamCtorShape(streamBase.def.name).accepted;
                     for (const [option, methodName] of UNDERSCORE_METHODS) {
                         if (name === methodName && !accepted.includes(option)) {
-                            L.unsupported("SC1090", memberName, `declaring '${name}' on a ${streamBase.def.name.slice(1)} subclass (its constructor consumes ${accepted.map((a) => `'${UNDERSCORE_METHODS.get(a)}'`).join("/")})`);
+                            lowerer.unsupported("SC1090", memberName, `declaring '${name}' on a ${streamBase.def.name.slice(1)} subclass (its constructor consumes ${accepted.map((a) => `'${UNDERSCORE_METHODS.get(a)}'`).join("/")})`);
                         }
                     }
                 }
@@ -1127,13 +1117,13 @@ mixin) {
                 if (modifiers?.some((m) => m.kind === ts.SyntaxKind.AccessorKeyword)) {
                     // `accessor x = 1` desugars (in JS) to a private slot plus a
                     // get/set pair — declare the field and accessors explicitly.
-                    L.unsupported("SC1090", member, "auto-accessor fields ('accessor x')");
+                    lowerer.unsupported("SC1090", member, "auto-accessor fields ('accessor x')");
                 }
                 // #private fields ride the ordinary field machinery — the '#'
                 // name is unspellable publicly, so the slot never collides, and
                 // enumeration surfaces (inspect) exclude it like Node.
                 if (!ts.isIdentifier(member.name) && !ts.isPrivateIdentifier(member.name)) {
-                    L.unsupported("SC1090", member, "computed field names");
+                    lowerer.unsupported("SC1090", member, "computed field names");
                 }
                 // A field initialized with a GENERIC arrow/function expression
                 // (`time = async <T>(label, fn) => {...}` — the Output.time
@@ -1148,15 +1138,15 @@ mixin) {
                 // an annotation that pins a concrete signature makes an ordinary
                 // closure field, which the normal path below owns.
                 if (genericFieldFnNodeOf(member) !== null &&
-                    isGenericCallableMemberType(L.typeOf(member.name), L.checker)) {
+                    isGenericCallableMemberType(lowerer.typeOf(member.name), lowerer.checker)) {
                     if (fields.has(member.name.text)) {
-                        L.unsupported("SC1090", member.name, "redeclaring inherited fields");
+                        lowerer.unsupported("SC1090", member.name, "redeclaring inherited fields");
                     }
-                    if (L.findMethodOn(base, member.name.text)) {
-                        L.unsupported("SC1090", member.name, "fields shadowing inherited methods");
+                    if (lowerer.findMethodOn(base, member.name.text)) {
+                        lowerer.unsupported("SC1090", member.name, "fields shadowing inherited methods");
                     }
-                    if (findGenericMethodOn(L, base, member.name.text)) {
-                        L.unsupported("SC1090", member.name, `redeclaring the inherited generic member '${member.name.text}' (generic members dispatch statically, so the base's call sites could never reach this redeclaration)`);
+                    if (findGenericMethodOn(lowerer, base, member.name.text)) {
+                        lowerer.unsupported("SC1090", member.name, `redeclaring the inherited generic member '${member.name.text}' (generic members dispatch statically, so the base's call sites could never reach this redeclaration)`);
                     }
                     collectGenericMember(member, false);
                     continue;
@@ -1165,8 +1155,8 @@ mixin) {
                 // the two dispatch worlds (static per-instantiation calls would
                 // never see the field's value) — the method-vs-generic mixing
                 // fence, field form.
-                if (findGenericMethodOn(L, base, member.name.text)) {
-                    L.unsupported("SC1090", member.name, `fields shadowing the inherited generic member '${member.name.text}' (generic members dispatch statically and would never reach this field's value)`);
+                if (findGenericMethodOn(lowerer, base, member.name.text)) {
+                    lowerer.unsupported("SC1090", member.name, `fields shadowing the inherited generic member '${member.name.text}' (generic members dispatch statically and would never reach this field's value)`);
                 }
                 // OPTIONAL fields (`a?: string`) are the record-field precedent
                 // applied to class shapes: the checker already types the slot
@@ -1174,13 +1164,13 @@ mixin) {
                 // undefined arm (undefFieldInitLineC — Node defines the property
                 // as undefined on construction, verified), and reads/writes ride
                 // the ordinary undefined-armed union machinery.
-                const type = L.irTypeOf(member.name);
+                const type = lowerer.irTypeOf(member.name);
                 if (type.kind === "void")
-                    L.badType(member.name, L.typeOf(member.name));
+                    lowerer.badType(member.name, lowerer.typeOf(member.name));
                 // dyn stays out of class fields (KEEP NARROW; record
                 // fields and array elements are unmappable via mapType already).
                 if (type.kind === "dyn") {
-                    L.unsupported("SC1090", member.name, "'unknown'-typed class fields");
+                    lowerer.unsupported("SC1090", member.name, "'unknown'-typed class fields");
                 }
                 if (fields.has(member.name.text)) {
                     // REDECLARING an inherited field: Node [[Define]]s the OWN
@@ -1200,12 +1190,12 @@ mixin) {
                         fieldOrder.push({ name: member.name.text, type, initializer: member.initializer, redeclared: true });
                         continue;
                     }
-                    L.unsupported("SC1090", member.name, member.initializer
+                    lowerer.unsupported("SC1090", member.name, member.initializer
                         ? "redeclaring inherited fields at a different type"
                         : "redeclaring inherited fields without an initializer (Node resets the field to undefined)");
                 }
-                if (L.findMethodOn(base, member.name.text)) {
-                    L.unsupported("SC1090", member.name, "fields shadowing inherited methods");
+                if (lowerer.findMethodOn(base, member.name.text)) {
+                    lowerer.unsupported("SC1090", member.name, "fields shadowing inherited methods");
                 }
                 // Initializer-less fields whose type ADMITS undefined start as
                 // JS's undefined (the allocation writes the interned undefined
@@ -1221,10 +1211,10 @@ mixin) {
                 // list checked against the constructor after the member loop
                 // (the constructor may be declared later in the class body).
                 const admitsUndefined = (type.kind === "union" &&
-                    (L.unions.get(type.unionId)?.arms.some((a) => a.kind === "undefinedT") ?? false)) ||
+                    (lowerer.unions.get(type.unionId)?.arms.some((a) => a.kind === "undefinedT") ?? false)) ||
                     type.kind === "jsval";
                 if (!member.initializer && !admitsUndefined) {
-                    const opts = L.program.getCompilerOptions();
+                    const opts = lowerer.program.getCompilerOptions();
                     const spi = opts.strictPropertyInitialization ?? opts.strict ?? false;
                     if (member.postfixToken?.kind === ts.SyntaxKind.ExclamationToken) {
                         unguardedFields.push({
@@ -1253,7 +1243,7 @@ mixin) {
                 if (!member.body)
                     continue;
                 if (ctor)
-                    L.unsupported("SC1090", member, "constructor overloads");
+                    lowerer.unsupported("SC1090", member, "constructor overloads");
                 // PARAMETER PROPERTIES (`constructor(public x: number)`): pure
                 // sugar — the parameter declares a field and assigns it from the
                 // parameter's value. Visibility (public/private/protected) and
@@ -1277,39 +1267,39 @@ mixin) {
                         // Non-keyword modifiers (parameter decorators) are rejected
                         // by tsc under standard decorators; defensive.
                         if (p.modifiers?.length)
-                            L.unsupported("SC1090", p, "this parameter form");
+                            lowerer.unsupported("SC1090", p, "this parameter form");
                         continue;
                     }
                     // tsc rejects binding patterns (TS1187) and rest params
                     // (TS1317) as parameter properties; defensive.
                     if (!ts.isIdentifier(p.name) || p.dotDotDotToken) {
-                        L.unsupported("SC1090", p, "this parameter property form");
+                        lowerer.unsupported("SC1090", p, "this parameter property form");
                     }
                     const name = p.name.text;
-                    const shape = L.paramShape(p);
+                    const shape = lowerer.paramShape(p);
                     const type = shape.bodyType ?? shape.type;
                     if (type.kind === "void")
-                        L.badType(p.name, L.typeOf(p.name));
+                        lowerer.badType(p.name, lowerer.typeOf(p.name));
                     // The class-field dyn rule verbatim (KEEP NARROW).
                     if (type.kind === "dyn") {
-                        L.unsupported("SC1090", p.name, "'unknown'-typed class fields");
+                        lowerer.unsupported("SC1090", p.name, "'unknown'-typed class fields");
                     }
                     // `override x` (and any same-named inherited member) would
                     // redeclare a base slot — the declared-field rule verbatim.
                     if (fields.has(name)) {
-                        L.unsupported("SC1090", p.name, "redeclaring inherited fields");
+                        lowerer.unsupported("SC1090", p.name, "redeclaring inherited fields");
                     }
-                    if (L.findMethodOn(base, name)) {
-                        L.unsupported("SC1090", p.name, "fields shadowing inherited methods");
+                    if (lowerer.findMethodOn(base, name)) {
+                        lowerer.unsupported("SC1090", p.name, "fields shadowing inherited methods");
                     }
                     paramProps.push({ name, type, param: p });
                 }
                 ctor = member;
             }
             else if (ts.isMethodDeclaration(member)) {
-                const mName = classMemberNameOf(L, member.name);
+                const mName = classMemberNameOf(lowerer, member.name);
                 if (mName === null)
-                    L.unsupported("SC1090", member, "computed method names");
+                    lowerer.unsupported("SC1090", member, "computed method names");
                 // PUBLIC generator METHODS stay fenced (virtualCall dispatch
                 // over gen-spawn wrappers has no story yet); module-level
                 // function* and object-literal *methods compile — and #PRIVATE
@@ -1319,13 +1309,13 @@ mixin) {
                 // emitter routes through the gen-spawn wrapper with `this` as
                 // param 0 — the async-method precedent, generator form.
                 if (member.asteriskToken !== undefined && !ts.isPrivateIdentifier(member.name)) {
-                    L.unsupported("SC1071", member, "generator methods (a #private generator method compiles — privates never dispatch dynamically; or declare a module-level function* and call it from the method)");
+                    lowerer.unsupported("SC1071", member, "generator methods (a #private generator method compiles — privates never dispatch dynamically; or declare a module-level function* and call it from the method)");
                 }
                 // An async #private generator (`async *#m()`) is still an async
                 // generator — the blanket SC1071 fence.
                 if (member.asteriskToken !== undefined &&
                     member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
-                    L.unsupported("SC1071", member, "async generators (async function*)");
+                    lowerer.unsupported("SC1071", member, "async generators (async function*)");
                 }
                 // An ABSTRACT method is a signature with no body — type-world,
                 // except that it declares the vtable slot: calls through
@@ -1339,24 +1329,24 @@ mixin) {
                     // per-call-site instantiation needs a nearest declarer WITH a
                     // body, which an abstract declaration never has.
                     if (member.typeParameters !== undefined) {
-                        L.unsupported("SC1090", member, "abstract generic methods (generic methods monomorphize from the nearest declaration's body, and an abstract declaration has none)");
+                        lowerer.unsupported("SC1090", member, "abstract generic methods (generic methods monomorphize from the nearest declaration's body, and an abstract declaration has none)");
                     }
-                    const { shapes, ret } = abstractMemberSignature(L, member);
+                    const { shapes, ret } = abstractMemberSignature(lowerer, member);
                     if (fields.has(mName)) {
-                        L.unsupported("SC1090", member.name, "methods shadowing inherited fields");
+                        lowerer.unsupported("SC1090", member.name, "methods shadowing inherited fields");
                     }
-                    if (findGenericMethodOn(L, base, mName)) {
-                        L.unsupported("SC1090", member.name, `overriding the inherited generic method '${mName}' with a non-generic method (generic methods dispatch statically and would never reach this override)`);
+                    if (findGenericMethodOn(lowerer, base, mName)) {
+                        lowerer.unsupported("SC1090", member.name, `overriding the inherited generic method '${mName}' with a non-generic method (generic methods dispatch statically and would never reach this override)`);
                     }
                     // Abstract re-declarations keep the overridden ABI exactly,
                     // like any override (a concrete implementation below must
                     // agree with BOTH, which exactness makes one constraint).
-                    const overridden = L.findMethodOn(base, mName);
+                    const overridden = lowerer.findMethodOn(base, mName);
                     if (overridden &&
                         (overridden.sig.params.length !== shapes.length ||
                             !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
                             !typeEquals(overridden.sig.ret, ret))) {
-                        L.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                        lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
                     }
                     methods.set(mName, { params: shapes, ret, abstract: true });
                     continue;
@@ -1373,10 +1363,10 @@ mixin) {
                 // calls vs vtable slots — cannot see each other's overrides).
                 if (member.typeParameters !== undefined) {
                     if (fields.has(mName)) {
-                        L.unsupported("SC1090", member.name, "methods shadowing inherited fields");
+                        lowerer.unsupported("SC1090", member.name, "methods shadowing inherited fields");
                     }
-                    if (L.findMethodOn(base, mName)) {
-                        L.unsupported("SC1090", member.name, `overriding the inherited method '${mName}' with a generic method (generic methods dispatch statically, so the base's vtable slot could never reach this override)`);
+                    if (lowerer.findMethodOn(base, mName)) {
+                        lowerer.unsupported("SC1090", member.name, `overriding the inherited method '${mName}' with a generic method (generic methods dispatch statically, so the base's vtable slot could never reach this override)`);
                     }
                     collectGenericMember(member, false);
                     continue;
@@ -1408,9 +1398,9 @@ mixin) {
                     ts.isIdentifier(member.name) &&
                     inst === undefined && decl.typeParameters === undefined &&
                     !fields.has(member.name.text) &&
-                    !L.findMethodOn(base, member.name.text) &&
-                    !findGenericMethodOn(L, base, member.name.text)) {
-                    const implicit = implicitAnyParamSymbolsOf(L, member);
+                    !lowerer.findMethodOn(base, member.name.text) &&
+                    !findGenericMethodOn(lowerer, base, member.name.text)) {
+                    const implicit = implicitAnyParamSymbolsOf(lowerer, member);
                     if (implicit) {
                         genericMethods.set(member.name.text, {
                             decl: member,
@@ -1423,12 +1413,12 @@ mixin) {
                         continue;
                     }
                 }
-                const { shapes, funcType: ft } = L.lambdaSignature(member);
+                const { shapes, funcType: ft } = lowerer.lambdaSignature(member);
                 if (fields.has(mName)) {
-                    L.unsupported("SC1090", member.name, "methods shadowing inherited fields");
+                    lowerer.unsupported("SC1090", member.name, "methods shadowing inherited fields");
                 }
-                if (findGenericMethodOn(L, base, mName)) {
-                    L.unsupported("SC1090", member.name, `overriding the inherited generic method '${mName}' with a non-generic method (generic methods dispatch statically and would never reach this override)`);
+                if (findGenericMethodOn(lowerer, base, mName)) {
+                    lowerer.unsupported("SC1090", member.name, `overriding the inherited generic method '${mName}' with a non-generic method (generic methods dispatch statically and would never reach this override)`);
                 }
                 // Symbol-slot return refinement, INHERITED slots (own ctor-declared
                 // slots refine in the post-scan pass below — the constructor hasn't
@@ -1436,7 +1426,7 @@ mixin) {
                 // symbolFields/fields). Doing it before the exactness check keeps
                 // a derived override of a refined base method agreeing.
                 if (ft.ret.kind === "dyn") {
-                    const refined = symbolSlotReturnType(L, member, symbolFields, fields);
+                    const refined = symbolSlotReturnType(lowerer, member, symbolFields, fields);
                     if (refined)
                         ft.ret = refined;
                 }
@@ -1448,18 +1438,18 @@ mixin) {
                 // ABI types only (not modes) is deliberate: call sites complete
                 // against the STATIC receiver's shape, so `m(x?: number)` and
                 // `m(x: number | undefined)` interchange soundly in overrides.
-                const overridden = L.findMethodOn(base, mName);
+                const overridden = lowerer.findMethodOn(base, mName);
                 if (overridden?.declarer.builtinError) {
                     // Error.prototype.toString is a runtime implementation with no
                     // vtable slot — calls to it are direct, so an override could
                     // never be reached through a base-typed receiver.
-                    L.unsupported("SC1090", member.name, `overriding the builtin Error method '${mName}'`);
+                    lowerer.unsupported("SC1090", member.name, `overriding the builtin Error method '${mName}'`);
                 }
                 if (overridden &&
                     (overridden.sig.params.length !== shapes.length ||
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, shapes[i].type)) ||
                         !typeEquals(overridden.sig.ret, ft.ret))) {
-                    L.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
+                    lowerer.unsupported("SC1090", member.name, "overriding a method with a different signature (parameter and return types must match the base declaration exactly)");
                 }
                 const asyncMember = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
                 // Async methods dispatch STATICALLY (the body enters through its
@@ -1467,7 +1457,7 @@ mixin) {
                 // an override chain touching an async method on either end would
                 // put a spawn wrapper behind a virtual slot, so it fences.
                 if (overridden && (asyncMember || overridden.sig.async === true)) {
-                    L.unsupported("SC1090", member.name, `overriding ${overridden.sig.async === true ? "the async method" : "a method with an async method"} '${mName}' (async methods dispatch statically — the vtable slot machinery has no fiber-spawn story)`);
+                    lowerer.unsupported("SC1090", member.name, `overriding ${overridden.sig.async === true ? "the async method" : "a method with an async method"} '${mName}' (async methods dispatch statically — the vtable slot machinery has no fiber-spawn story)`);
                 }
                 // A #private GENERATOR method carries its channels on the sig:
                 // the body lowers as a generator IrFunction (`this` as param 0),
@@ -1475,7 +1465,7 @@ mixin) {
                 // emitted gen-spawn wrapper, answering the suspended generator.
                 if (member.asteriskToken !== undefined) {
                     if (ft.ret.kind !== "generator")
-                        L.badType(member.name, L.typeOf(member.name));
+                        lowerer.badType(member.name, lowerer.typeOf(member.name));
                     methods.set(mName, { params: shapes, ret: ft.ret, gen: { yieldT: ft.ret.yieldT, nextT: ft.ret.nextT } });
                 }
                 else {
@@ -1498,7 +1488,7 @@ mixin) {
                 // #private accessors collect as "get:#x"/"set:#x" — the same
                 // reserved spelling, one more unspellable segment.
                 if (!ts.isIdentifier(member.name) && !ts.isPrivateIdentifier(member.name)) {
-                    L.unsupported("SC1090", member, "computed accessor names");
+                    lowerer.unsupported("SC1090", member, "computed accessor names");
                 }
                 // ABSTRACT accessors are the abstract-method story with property
                 // syntax: body-less by definition, they enter `methods` (marked
@@ -1506,23 +1496,23 @@ mixin) {
                 // and override exactness verbatim; no module function exists.
                 const abstractAccessor = ts.getModifiers(member)?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) === true;
                 if (!member.body && !abstractAccessor)
-                    L.unsupported("SC1090", member, "bodyless accessors");
+                    lowerer.unsupported("SC1090", member, "bodyless accessors");
                 const prop = member.name.text;
                 const mName = `${isGet ? "get" : "set"}:${prop}`;
                 if (fields.has(prop)) {
                     // tsc rejects field/accessor mixing (TS2610/2611); defensive.
-                    L.unsupported("SC1090", member.name, "accessors sharing a name with a field");
+                    lowerer.unsupported("SC1090", member.name, "accessors sharing a name with a field");
                 }
                 let sig;
                 if (isGet) {
-                    const ret = L.declaredReturnType(member, member.name);
+                    const ret = lowerer.declaredReturnType(member, member.name);
                     if (ret.kind === "void")
-                        L.badType(member.name, L.typeOf(member.name));
+                        lowerer.badType(member.name, lowerer.typeOf(member.name));
                     sig = { params: [], ret };
                 }
                 else {
                     // tsc rejects optional/default/rest setter params (TS1051-53).
-                    sig = { params: L.paramShapes(member.parameters), ret: VOID };
+                    sig = { params: lowerer.paramShapes(member.parameters), ret: VOID };
                 }
                 // One property, ONE type: tsc (5.1+) admits get/set pairs with
                 // unrelated annotated types; a property slot here has a single
@@ -1531,16 +1521,16 @@ mixin) {
                 const twinType = twin ? (isGet ? twin.params[0].type : twin.ret) : null;
                 const ownType = isGet ? sig.ret : sig.params[0].type;
                 if (twinType && !typeEquals(twinType, ownType)) {
-                    L.unsupported("SC1090", member.name, `getter/setter pairs with different types (the property '${prop}' must have one type)`);
+                    lowerer.unsupported("SC1090", member.name, `getter/setter pairs with different types (the property '${prop}' must have one type)`);
                 }
                 // Same exactness rule as methods — an accessor override keeps
                 // the overridden accessor's type (getter return / setter param).
-                const overridden = L.findMethodOn(base, mName);
+                const overridden = lowerer.findMethodOn(base, mName);
                 if (overridden &&
                     (overridden.sig.params.length !== sig.params.length ||
                         !overridden.sig.params.every((p, i) => typeEquals(p.type, sig.params[i].type)) ||
                         !typeEquals(overridden.sig.ret, sig.ret))) {
-                    L.unsupported("SC1090", member.name, "overriding an accessor with a different type (the property type must match the base declaration exactly)");
+                    lowerer.unsupported("SC1090", member.name, "overriding an accessor with a different type (the property type must match the base declaration exactly)");
                 }
                 methods.set(mName, abstractAccessor ? { ...sig, abstract: true } : sig);
                 // Abstract accessors stay OUT of accessorNodes: they are erased
@@ -1551,10 +1541,10 @@ mixin) {
                     accessorNodes.set(mName, member);
             }
             else if (ts.isIndexSignatureDeclaration(member)) {
-                L.unsupported("SC1090", member, "index signatures");
+                lowerer.unsupported("SC1090", member, "index signatures");
             }
             else if (!ts.isSemicolonClassElement(member)) {
-                L.unsupported("SC1090", member, `syntax '${ts.SyntaxKind[member.kind]}'`);
+                lowerer.unsupported("SC1090", member, `syntax '${ts.SyntaxKind[member.kind]}'`);
             }
         }
         // Parameter properties join the shape FIRST among own fields —
@@ -1605,7 +1595,7 @@ mixin) {
                     declared.kind !== "map" && declared.kind !== "date" && declared.kind !== "generator" &&
                     declared.kind !== "void" &&
                     declared.kind !== "caught";
-                const armed = armable ? L.withUndefinedArm(declared) : null;
+                const armed = armable ? lowerer.withUndefinedArm(declared) : null;
                 if (armed !== null && armed.kind === "union") {
                     fields.set(f.name, armed);
                     const fo = fieldOrder.find((x) => x.name === f.name);
@@ -1614,7 +1604,7 @@ mixin) {
                     deferredInitFields.add(f.name);
                     continue;
                 }
-                L.unsupported("SC1090", f.node, f.why);
+                lowerer.unsupported("SC1090", f.node, f.why);
             }
         }
         // Partial overrides of an inherited accessor pair. JS gives the
@@ -1636,13 +1626,13 @@ mixin) {
                 // no accessor pair to shadow, so no throwing setter to
                 // synthesize (tsc makes an instantiable class implement it, and
                 // that implementation shadows nothing either).
-                const baseSet = L.findMethodOn(base, `set:${prop}`);
+                const baseSet = lowerer.findMethodOn(base, `set:${prop}`);
                 if (baseSet && baseSet.sig.abstract !== true) {
                     if (!typeEquals(baseSet.sig.params[0].type, methods.get(mName).ret)) {
                         // Unreachable when the base pair agrees (induction through
                         // the exactness rule); a base setter-only + new getter of a
                         // different type would break the slot signature.
-                        L.unsupported("SC1090", node.name, "accessors whose getter and inherited setter types differ");
+                        lowerer.unsupported("SC1090", node.name, "accessors whose getter and inherited setter types differ");
                     }
                     methods.set(`set:${prop}`, { params: [baseSet.sig.params[0]], ret: VOID });
                     throwingSetters.push(prop);
@@ -1650,9 +1640,9 @@ mixin) {
             }
             if (mName.startsWith("set:") && !accessorNodes.has(`get:${prop}`)) {
                 // The abstract-inherited-getter case is the same erasure story.
-                const baseGet = L.findMethodOn(base, `get:${prop}`);
+                const baseGet = lowerer.findMethodOn(base, `get:${prop}`);
                 if (baseGet && baseGet.sig.abstract !== true) {
-                    L.unsupported("SC1090", node.name, `overriding only the setter of an inherited accessor pair (JS shadows the inherited getter — reads of '${prop}' would yield undefined; declare the getter too)`);
+                    lowerer.unsupported("SC1090", node.name, `overriding only the setter of an inherited accessor pair (JS shadows the inherited getter — reads of '${prop}' would yield undefined; declare the getter too)`);
                 }
             }
         }
@@ -1672,8 +1662,8 @@ mixin) {
             // Named classes (declarations and self-binding expressions) resolve
             // by name; the nameless default-export declaration by its module's
             // default-export symbol.
-            const classSym = decl.name ? L.checker.getSymbolAtLocation(decl.name) : ts.isClassDeclaration(decl) ? declSymbolOf(L, decl) : undefined;
-            const instType = classSym ? L.checker.getDeclaredTypeOfSymbol(classSym) : undefined;
+            const classSym = decl.name ? lowerer.checker.getSymbolAtLocation(decl.name) : ts.isClassDeclaration(decl) ? declSymbolOf(lowerer, decl) : undefined;
+            const instType = classSym ? lowerer.checker.getDeclaredTypeOfSymbol(classSym) : undefined;
             // LATE-BOUND properties (the checker's `__@name@id` spelling —
             // `this[kLimit] = v` where kLimit is a unique symbol const) by
             // their KEY symbol: the scan below needs the checker's property
@@ -1682,10 +1672,10 @@ mixin) {
             // answers null on element-access declaration sites, so the link
             // goes through the key.
             const lateBoundByKey = new Map();
-            for (const p of instType ? L.checker.getPropertiesOfType(instType) : []) {
+            for (const p of instType ? lowerer.checker.getPropertiesOfType(instType) : []) {
                 if (!p.name.startsWith("__@"))
                     continue;
-                const keySym = lateBoundKeySymOf(L, p);
+                const keySym = lateBoundKeySymOf(lowerer, p);
                 if (keySym)
                     lateBoundByKey.set(keySym, p);
             }
@@ -1704,20 +1694,20 @@ mixin) {
                         // inherited) are writes, not declarations.
                         if (fields.has(name))
                             continue;
-                        if (methods.has(name) || L.findMethodOn(base, name)) {
-                            L.unsupported("SC1090", assign, "constructor-assigned fields shadowing methods");
+                        if (methods.has(name) || lowerer.findMethodOn(base, name)) {
+                            lowerer.unsupported("SC1090", assign, "constructor-assigned fields shadowing methods");
                         }
-                        const sym = L.checker.getSymbolAtLocation(assign);
-                        const t = sym ? L.checker.getTypeOfSymbol(sym) : undefined;
+                        const sym = lowerer.checker.getSymbolAtLocation(assign);
+                        const t = sym ? lowerer.checker.getTypeOfSymbol(sym) : undefined;
                         // Implicit-any fields (assigned from UNTYPED ctor params —
                         // countdown.js's `this.limit = limit`) take the JS checked-
                         // dynamic fallback like every JS binding: the slot holds a dyn
                         // box, reads validate per use, writes convert in (dynFrom).
                         // TS-annotated `unknown` fields keep their fence (KEEP NARROW
                         // applies where an annotation could say better).
-                        let type = t ? (L.mapTypeOf(t) ?? dynFallbackType(L, assign, t)) : null;
+                        let type = t ? (lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, assign, t)) : null;
                         if (!type || type.kind === "void")
-                            L.badType(assign, t ?? L.typeOf(assign));
+                            lowerer.badType(assign, t ?? lowerer.typeOf(assign));
                         // A JSDoc claim the BODY contradicts (`@type {Command}`
                         // assigned `undefined` — the lazy-init idiom): the
                         // representation follows the body — the field widens to the
@@ -1726,13 +1716,13 @@ mixin) {
                         // Trust-but-verify: the claim never silently narrows the
                         // runtime value.
                         {
-                            const rhsT = L.typeOf(stmt.expression.right);
+                            const rhsT = lowerer.typeOf(stmt.expression.right);
                             const assignsUndef = (rhsT.flags & ts.TypeFlags.Undefined) !== 0;
                             const admitsUndef = type.kind === "dyn" ||
                                 isUnitType(type) ||
-                                (type.kind === "union" && L.armTag(type.unionId, UNDEFINED_T) >= 0);
+                                (type.kind === "union" && lowerer.armTag(type.unionId, UNDEFINED_T) >= 0);
                             if (assignsUndef && !admitsUndef) {
-                                const widened = L.withUndefinedArmOf(type);
+                                const widened = lowerer.withUndefinedArmOf(type);
                                 if (widened !== null)
                                     type = widened;
                             }
@@ -1752,7 +1742,7 @@ mixin) {
                     // late-bound fence below.
                     if (lhs && ts.isElementAccessExpression(lhs) &&
                         lhs.expression.kind === ts.SyntaxKind.ThisKeyword) {
-                        const key = uniqueSymbolKeyOf(L, lhs.argumentExpression);
+                        const key = uniqueSymbolKeyOf(lowerer, lhs.argumentExpression);
                         if (!key)
                             continue;
                         // A key already declared (own or inherited) makes later
@@ -1762,7 +1752,7 @@ mixin) {
                         if (fields.has(key.fieldName)) {
                             // Two DISTINCT Symbol(...) consts with one description in
                             // one layout would need one printable name for two slots.
-                            L.unsupported("SC1090", lhs, `distinct symbol keys sharing the printable name '${key.fieldName}' in one class`);
+                            lowerer.unsupported("SC1090", lhs, `distinct symbol keys sharing the printable name '${key.fieldName}' in one class`);
                         }
                         const propSym = lateBoundByKey.get(key.sym);
                         // tsgo does not synthesize the late-bound `__@name@id`
@@ -1775,13 +1765,13 @@ mixin) {
                             ? stmt.expression.right
                             : undefined;
                         const t = propSym
-                            ? L.checker.getTypeOfSymbol(propSym)
+                            ? lowerer.checker.getTypeOfSymbol(propSym)
                             : rhs
-                                ? L.checker.getBaseTypeOfLiteralType(L.checker.getTypeAtLocation(rhs))
+                                ? lowerer.checker.getBaseTypeOfLiteralType(lowerer.checker.getTypeAtLocation(rhs))
                                 : undefined;
-                        const type = t ? (L.mapTypeOf(t) ?? dynFallbackType(L, lhs, t)) : null;
+                        const type = t ? (lowerer.mapTypeOf(t) ?? dynFallbackType(lowerer, lhs, t)) : null;
                         if (!type || type.kind === "void")
-                            L.badType(lhs, t ?? L.typeOf(lhs));
+                            lowerer.badType(lhs, t ?? lowerer.typeOf(lhs));
                         fields.set(key.fieldName, type);
                         symbolFields.set(key.sym, key.fieldName);
                         fieldOrder.push({ name: key.fieldName, type, initializer: undefined });
@@ -1793,14 +1783,14 @@ mixin) {
             // computed keys — is undefined until its first write, which these
             // static layouts cannot represent. Named fence, at the first
             // assignment site.
-            for (const p of instType ? L.checker.getPropertiesOfType(instType) : []) {
+            for (const p of instType ? lowerer.checker.getPropertiesOfType(instType) : []) {
                 if (fields.has(p.name) || methods.has(p.name))
                     continue;
                 if (methods.has(`get:${p.name}`) || methods.has(`set:${p.name}`))
                     continue;
-                if (base && (base.fields.has(p.name) || L.findMethodOn(base, p.name)))
+                if (base && (base.fields.has(p.name) || lowerer.findMethodOn(base, p.name)))
                     continue;
-                const site = L.checker.declarationsOf(p).find((d) => ts.isPropertyAccessExpression(d) || ts.isBinaryExpression(d) ||
+                const site = lowerer.checker.declarationsOf(p).find((d) => ts.isPropertyAccessExpression(d) || ts.isBinaryExpression(d) ||
                     ts.isElementAccessExpression(d));
                 if (!site)
                     continue;
@@ -1811,10 +1801,10 @@ mixin) {
                 // descriptions) or assignments outside the constructor's top
                 // level.
                 if (p.name.startsWith("__@")) {
-                    const keySym = lateBoundKeySymOf(L, p);
+                    const keySym = lateBoundKeySymOf(lowerer, p);
                     if (keySym && symbolFields.has(keySym))
                         continue;
-                    L.unsupported("SC1090", site, "symbol-keyed class fields outside the supported form (a module-level `const k = Symbol('desc')` key, assigned unconditionally at the top of the constructor)");
+                    lowerer.unsupported("SC1090", site, "symbol-keyed class fields outside the supported form (a module-level `const k = Symbol('desc')` key, assigned unconditionally at the top of the constructor)");
                 }
                 // JS classes: a property first assigned in a method or a
                 // conditional constructor position holds `undefined` until the
@@ -1827,14 +1817,14 @@ mixin) {
                 // TypeScript classes keep the loud fence too: an annotated
                 // program can spell `T | undefined` itself.
                 if (isJsSourceFile(decl.getSourceFile())) {
-                    const armed = undefArmedFieldType(L, p);
+                    const armed = undefArmedFieldType(lowerer, p);
                     if (armed !== null) {
                         fields.set(p.name, armed);
                         fieldOrder.push({ name: p.name, type: armed, initializer: undefined });
                         continue;
                     }
                 }
-                L.unsupported("SC1090", site, `fields assigned outside the constructor's top level ('this.${p.name}' would be undefined until the first assignment runs — assign it unconditionally at the top of the constructor)`);
+                lowerer.unsupported("SC1090", site, `fields assigned outside the constructor's top level ('this.${p.name}' would be undefined until the first assignment runs — assign it unconditionally at the top of the constructor)`);
             }
         }
         // Second refinement chance, OWN symbol slots: the member loop ran
@@ -1845,7 +1835,7 @@ mixin) {
             const sig = methods.get(mName);
             if (!sig || sig.ret.kind !== "dyn")
                 continue;
-            const refined = symbolSlotReturnType(L, node, symbolFields, fields);
+            const refined = symbolSlotReturnType(lowerer, node, symbolFields, fields);
             if (refined)
                 sig.ret = refined;
         }
@@ -1857,15 +1847,15 @@ mixin) {
         // parameter never materializes. A rest constructor in a mixin that
         // is NOT the pure forwarding shape has no static story — named
         // fence, never a mis-typed array.
-        const mixinForwarding = mixin !== undefined && ctor !== null && mixinForwardingCtor(L, ctor);
+        const mixinForwarding = mixin !== undefined && ctor !== null && mixinForwardingCtor(lowerer, ctor);
         if (mixin && ctor && !mixinForwarding && ctor.parameters.some((p) => p.dotDotDotToken)) {
-            L.unsupported("SC1090", ctor.parameters.find((p) => p.dotDotDotToken), "mixin constructors whose rest parameter does anything but forward (`super(...args)` as the first statement is the compiled shape)");
+            lowerer.unsupported("SC1090", ctor.parameters.find((p) => p.dotDotDotToken), "mixin constructors whose rest parameter does anything but forward (`super(...args)` as the first statement is the compiled shape)");
         }
         // Constructor omitted on a derived class: it inherits the base's
         // (tsc types `new Derived(...)` against the inherited signature; the
         // synthesized constructor forwards the same params to super).
         const ctorParams = ctor && !mixinForwarding
-            ? L.paramShapes(ctor.parameters)
+            ? lowerer.paramShapes(ctor.parameters)
             : (base?.ctorParams ?? []);
         const info = {
             def: {
@@ -1944,9 +1934,9 @@ mixin) {
         if (familyMode) {
             const typeParams = [];
             for (const tp of decl.typeParameters) {
-                const sym = L.checker.getSymbolAtLocation(tp.name);
+                const sym = lowerer.checker.getSymbolAtLocation(tp.name);
                 if (!sym)
-                    L.unsupported("SC1090", tp, "this type parameter form");
+                    lowerer.unsupported("SC1090", tp, "this type parameter form");
                 typeParams.push(sym);
             }
             info.generic = {
@@ -1956,11 +1946,11 @@ mixin) {
                 family: info,
                 instances: new Map(),
             };
-            L.genericClassByDecl.set(decl, info.generic);
+            lowerer.genericClassByDecl.set(decl, info.generic);
         }
         if (base)
             base.subclasses.push(info);
-        L.classes.set(className, info);
+        lowerer.classes.set(className, info);
         // A NAMED class binds its name (declarations in their scope, class
         // expressions inside their own bodies — tsc resolves both to this
         // symbol); a nameless default-export declaration binds its module's
@@ -1971,14 +1961,14 @@ mixin) {
         // classes fence at their use sites).
         const classSymbol = inst || mixin
             ? undefined
-            : decl.name ? L.checker.getSymbolAtLocation(decl.name) : ts.isClassDeclaration(decl) ? declSymbolOf(L, decl) : undefined;
+            : decl.name ? lowerer.checker.getSymbolAtLocation(decl.name) : ts.isClassDeclaration(decl) ? declSymbolOf(lowerer, decl) : undefined;
         if (classSymbol)
-            L.classBySymbol.set(classSymbol, info);
+            lowerer.classBySymbol.set(classSymbol, info);
         // Static-field storage registers with the module's globals only
         // once the whole shape collected (a poisoned class never leaves a
         // half-registered global behind).
         for (const f of staticFields) {
-            L.globalsList.push({ id: f.globalId, name: `${info.def.jsName ?? className}.${f.name}`, type: f.type, mutable: !f.readonly });
+            lowerer.globalsList.push({ id: f.globalId, name: `${info.def.jsName ?? className}.${f.name}`, type: f.type, mutable: !f.readonly });
         }
     }
 }
@@ -1992,15 +1982,15 @@ mixin) {
    * unmapped, the fenced-JS-class story. Null answers (unmappable type
    * arguments, the instance cap, an uncollected family) make the whole
    * reference unmappable — per-site diagnostics own the fence. */
-export function genericClassInstanceType(L, decl, ref) {
-    const gci = L.genericClassByDecl.get(decl);
+export function genericClassInstanceType(lowerer, decl, ref) {
+    const gci = lowerer.genericClassByDecl.get(decl);
     if (!gci) {
         // The family never collected (a deferred/poisoned declaration): the
         // pre-generics answer — the class's own name, unregistered, so dead
         // storage prunes (typeNamesUnregisteredClass) and live references
         // flush the declaration's deferred diagnostics (moduleArtifacts /
         // the validator backstop). Exactly the fenced-class story.
-        return { kind: "object", className: L.classNamer(decl) };
+        return { kind: "object", className: lowerer.classNamer(decl) };
     }
     // A degenerate reference collapses to the FAMILY's object type instead
     // of going unmapped: `Box<any>` under a static build, wilder arguments
@@ -2015,11 +2005,11 @@ export function genericClassInstanceType(L, decl, ref) {
     const familyT = { kind: "object", className: gci.family.def.name };
     // The checker appends `this` (and outer type parameters) to
     // getTypeArguments — only the declaration's own count participates.
-    const args = L.checker.getTypeArguments(ref).slice(0, gci.typeParams.length);
+    const args = lowerer.checker.getTypeArguments(ref).slice(0, gci.typeParams.length);
     const mapped = [];
     if (args.length === gci.typeParams.length) {
         for (const a of args) {
-            const m = L.mapTypeOf(a);
+            const m = lowerer.mapTypeOf(a);
             if (!m || m.kind === "void") {
                 // An UNBOUND type parameter argument (`Box<T>` outside any
                 // instantiation) stays honestly unmapped — nothing concrete is
@@ -2035,7 +2025,7 @@ export function genericClassInstanceType(L, decl, ref) {
         // Inside an instantiation the CURRENT bindings are the arguments;
         // anywhere else the reference is honestly unmappable.
         for (const tp of gci.typeParams) {
-            const b = L.typeParamBindings?.get(tp);
+            const b = lowerer.typeParamBindings?.get(tp);
             if (!b)
                 return null;
             mapped.push(b);
@@ -2045,7 +2035,7 @@ export function genericClassInstanceType(L, decl, ref) {
     const existing = gci.instances.get(key);
     if (existing) {
         if (existing.info)
-            L.noteGenericClassInstanceDemand(existing.info);
+            lowerer.noteGenericClassInstanceDemand(existing.info);
         return existing.poisoned ? null : { kind: "object", className: existing.name };
     }
     // The generic-fn cap, same rationale (polymorphic recursion through
@@ -2060,14 +2050,14 @@ export function genericClassInstanceType(L, decl, ref) {
     gci.instances.set(key, entry);
     const bindings = new Map();
     gci.typeParams.forEach((tp, i) => bindings.set(tp, mapped[i]));
-    const rendered = mapped.map((m) => L.fmt(m)).join(", ");
+    const rendered = mapped.map((m) => lowerer.fmt(m)).join(", ");
     const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`;
-    const prevBindings = L.typeParamBindings;
-    const prevContext = L.instantiationContext;
-    L.typeParamBindings = bindings;
-    L.instantiationContext = `instantiating class '${gci.baseName}' with ${typeArgsText}`;
+    const prevBindings = lowerer.typeParamBindings;
+    const prevContext = lowerer.instantiationContext;
+    lowerer.typeParamBindings = bindings;
+    lowerer.instantiationContext = `instantiating class '${gci.baseName}' with ${typeArgsText}`;
     try {
-        L.collectClassShapeInner(decl, undefined, { family: gci.family, name, bindings, typeArgsText, ordinal });
+        lowerer.collectClassShapeInner(decl, undefined, { family: gci.family, name, bindings, typeArgsText, ordinal });
     }
     catch (e) {
         // Collection fenced under THESE bindings: the diagnostic (with the
@@ -2078,18 +2068,18 @@ export function genericClassInstanceType(L, decl, ref) {
         return null;
     }
     finally {
-        L.typeParamBindings = prevBindings;
-        L.instantiationContext = prevContext;
+        lowerer.typeParamBindings = prevBindings;
+        lowerer.instantiationContext = prevContext;
     }
-    const info = L.classes.get(name);
+    const info = lowerer.classes.get(name);
     if (!info) {
         entry.poisoned = true;
         return null;
     }
     entry.info = info;
-    L.genericClassInstances.push(info);
-    L.noteGenericClassInstanceDemand(info);
-    L.onLateClassCollected?.(info);
+    lowerer.genericClassInstances.push(info);
+    lowerer.noteGenericClassInstanceDemand(info);
+    lowerer.onLateClassCollected?.(info);
     return { kind: "object", className: name };
 }
 /** Runs a member-lowering thunk under an INSTANTIATION's type-parameter
@@ -2098,7 +2088,7 @@ export function genericClassInstanceType(L, decl, ref) {
    * Coverage counts a generic class's statements once: only the FIRST
    * instantiation contributes (the lowerGenericInstance rule). A no-op
    * for ordinary classes. */
-export function withInstanceBindings(L, info, fn) {
+function withInstanceBindings(lowerer, info, fn) {
     const gi = info.genericInstance;
     if (!gi) {
         // MIXIN instantiations ride the same mechanism: T (the base
@@ -2108,37 +2098,37 @@ export function withInstanceBindings(L, info, fn) {
         const mi = info.mixinInstance;
         if (!mi)
             return fn();
-        const prevBindings = L.typeParamBindings;
-        const prevContext = L.instantiationContext;
-        const prevSuppress = L.suppressStats;
-        const prevMixinCtx = L.mixinTypeContext;
-        L.typeParamBindings = mi.bindings;
-        L.instantiationContext = mi.context;
-        L.suppressStats = prevSuppress || mi.ordinal > 0;
-        L.mixinTypeContext = { classNode: info.decl, className: info.def.name };
+        const prevBindings = lowerer.typeParamBindings;
+        const prevContext = lowerer.instantiationContext;
+        const prevSuppress = lowerer.suppressStats;
+        const prevMixinCtx = lowerer.mixinTypeContext;
+        lowerer.typeParamBindings = mi.bindings;
+        lowerer.instantiationContext = mi.context;
+        lowerer.suppressStats = prevSuppress || mi.ordinal > 0;
+        lowerer.mixinTypeContext = { classNode: info.decl, className: info.def.name };
         try {
             return fn();
         }
         finally {
-            L.typeParamBindings = prevBindings;
-            L.instantiationContext = prevContext;
-            L.suppressStats = prevSuppress;
-            L.mixinTypeContext = prevMixinCtx;
+            lowerer.typeParamBindings = prevBindings;
+            lowerer.instantiationContext = prevContext;
+            lowerer.suppressStats = prevSuppress;
+            lowerer.mixinTypeContext = prevMixinCtx;
         }
     }
-    const prevBindings = L.typeParamBindings;
-    const prevContext = L.instantiationContext;
-    const prevSuppress = L.suppressStats;
-    L.typeParamBindings = gi.bindings;
-    L.instantiationContext = `instantiating class '${gi.family.generic?.baseName ?? info.def.jsName ?? ""}' with ${gi.typeArgsText}`;
-    L.suppressStats = prevSuppress || gi.ordinal > 0;
+    const prevBindings = lowerer.typeParamBindings;
+    const prevContext = lowerer.instantiationContext;
+    const prevSuppress = lowerer.suppressStats;
+    lowerer.typeParamBindings = gi.bindings;
+    lowerer.instantiationContext = `instantiating class '${gi.family.generic?.baseName ?? info.def.jsName ?? ""}' with ${gi.typeArgsText}`;
+    lowerer.suppressStats = prevSuppress || gi.ordinal > 0;
     try {
         return fn();
     }
     finally {
-        L.typeParamBindings = prevBindings;
-        L.instantiationContext = prevContext;
-        L.suppressStats = prevSuppress;
+        lowerer.typeParamBindings = prevBindings;
+        lowerer.instantiationContext = prevContext;
+        lowerer.suppressStats = prevSuppress;
     }
 }
 /** The `%init` statements for one class's static readonly fields AND
@@ -2147,18 +2137,18 @@ export function withInstanceBindings(L, info, fn) {
    * JS evaluates static initializers and blocks. Field failures poison per
    * field, like fieldInitStmts; a block lowers as the block statement it
    * is, so its statements poison individually inside lowerStmts. */
-export function lowerStaticFieldInits(L, info) {
+export function lowerStaticFieldInits(lowerer, info) {
     // Mixin instantiations lower their initializers under the
     // instantiation's bindings/context (a no-op for everything else —
     // generic FAMILIES own their statics and carry no genericInstance).
-    return withInstanceBindings(L, info, () => lowerStaticFieldInitsInner(L, info));
+    return withInstanceBindings(lowerer, info, () => lowerStaticFieldInitsInner(lowerer, info));
 }
-function lowerStaticFieldInitsInner(L, info) {
+function lowerStaticFieldInitsInner(lowerer, info) {
     // Decoration first: TC39 evaluates decorator expressions, creates the
     // class, applies the decorators, and only THEN runs static field
     // initializers and static blocks (verified against Node — the
     // decorated result is what `this`/the class name mean inside them).
-    const out = [...lowerClassDecoration(L, info)];
+    const out = [...lowerClassDecoration(lowerer, info)];
     const items = [
         ...info.staticFields.map((f) => ({ pos: f.initializer.getStart(), kind: "field", f })),
         ...(info.staticBlocks ?? []).map((b) => ({ pos: b.getStart(), kind: "block", b })),
@@ -2167,38 +2157,26 @@ function lowerStaticFieldInitsInner(L, info) {
         if (item.kind === "block") {
             // The block's body IS a Block statement: lowerStmts scopes its
             // let/const like any nested block and poisons per inner statement.
-            out.push(...L.lowerStmts([item.b.body]));
+            out.push(...lowerer.lowerStmts([item.b.body]));
             continue;
         }
         const f = item.f;
-        L.stats.statementsTotal++;
-        L.bumpFileStat(locOf(f.initializer).file, "total");
+        lowerer.stats.statementsTotal++;
+        lowerer.bumpFileStat(locOf(f.initializer).file, "total");
         try {
             // `this` in a static field initializer names the CLASS (like a
             // static block's), with arrows transparent and this-binding
             // function forms opaque — the static-block rule verbatim, named
             // here so the generic outside-a-method fence never fires first.
-            const checkThis = (n) => {
-                if (ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n) ||
-                    ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n) ||
-                    ts.isGetAccessor(n) || ts.isSetAccessor(n) ||
-                    ts.isClassDeclaration(n) || ts.isClassExpression(n)) {
-                    return;
-                }
-                if (n.kind === ts.SyntaxKind.ThisKeyword || n.kind === ts.SyntaxKind.SuperKeyword) {
-                    L.unsupported("SC1090", n, "'this' in static field initializers (it names the class — reference the class by name instead)");
-                }
-                n.forEachChild(checkThis);
-            };
-            checkThis(f.initializer);
-            const value = L.lowerExprExpecting(f.initializer, f.type);
+            rejectStaticThis(lowerer, f.initializer, () => "'this' in static field initializers (it names the class — reference the class by name instead)", true);
+            const value = lowerer.lowerExprExpecting(f.initializer, f.type);
             out.push({ kind: "assign", localId: f.globalId, value, loc: locOf(f.initializer) });
         }
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
-            L.stats.statementsFailed++;
-            L.bumpFileStat(locOf(f.initializer).file, "failed");
+            lowerer.stats.statementsFailed++;
+            lowerer.bumpFileStat(locOf(f.initializer).file, "failed");
         }
     }
     return out;
@@ -2220,7 +2198,7 @@ function lowerStaticFieldInitsInner(L, info) {
    * build time; the runtime base would be the decoration result) and
    * namespace-nested declarations (qualified references resolve the class
    * directly, not through the rebound value). */
-export function analyzeClassDecoration(L, info) {
+export function analyzeClassDecoration(lowerer, info) {
     const cd = info.classDecorators;
     if (!cd || cd.shapes !== undefined || cd.poisoned)
         return;
@@ -2243,29 +2221,29 @@ export function analyzeClassDecoration(L, info) {
                     ? d.expression
                     : null;
             if (ambientCallee !== null) {
-                const sym = L.resolveValueSymbol(ambientCallee);
-                const vdecl = sym && !L.isStdlibSymbol(sym) ? L.checker.declarationsOf(sym)[0] : undefined;
+                const sym = lowerer.resolveValueSymbol(ambientCallee);
+                const vdecl = sym && !lowerer.isStdlibSymbol(sym) ? lowerer.checker.declarationsOf(sym)[0] : undefined;
                 const ambientVar = vdecl !== undefined &&
                     ts.isVariableDeclaration(vdecl) &&
                     vdecl.initializer === undefined &&
                     (ts.getCombinedModifierFlags(vdecl) & ts.ModifierFlags.Ambient) !== 0 &&
                     !vdecl.getSourceFile().isDeclarationFile;
-                if (ambientVar || ambientUndefinedFnSymbolOf(L, ambientCallee) !== null) {
+                if (ambientVar || ambientUndefinedFnSymbolOf(lowerer, ambientCallee) !== null) {
                     shapes.push({ kind: "ambientThrow", name: ambientCallee.text });
                     continue;
                 }
             }
-            const t = L.typeOf(d.expression);
+            const t = lowerer.typeOf(d.expression);
             // Param-count first, off the checker signature: the context-taking
             // shape deserves its own name before mapType (whose failure on
             // ClassDecoratorContext would blur the story).
-            const sigs = L.checker.getCallSignatures(t);
+            const sigs = lowerer.checker.getCallSignatures(t);
             if (sigs.length === 1 && sigs[0].getParameters().length > 1) {
-                L.unsupported("SC1090", d, "class decorators that take the standard 'context' parameter (its object — addInitializer, metadata — has no static lowering; single-parameter decorators compile)");
+                lowerer.unsupported("SC1090", d, "class decorators that take the standard 'context' parameter (its object — addInitializer, metadata — has no static lowering; single-parameter decorators compile)");
             }
-            const mapped = L.mapTypeOf(t);
+            const mapped = lowerer.mapTypeOf(t);
             if (!mapped || mapped.kind !== "func" || mapped.rest === true || mapped.params.length > 1) {
-                L.unsupported("SC1090", d, "class decorators without one concrete (class) => class-or-void signature ('any'-typed and generic decorators have no compilable call ABI — declare the parameter as the class type)");
+                lowerer.unsupported("SC1090", d, "class decorators without one concrete (class) => class-or-void signature ('any'-typed and generic decorators have no compilable call ABI — declare the parameter as the class type)");
             }
             // The parameter: a classval slot the decorated class's object can
             // legally inhabit — the class itself, or a BASE with the same
@@ -2274,13 +2252,13 @@ export function analyzeClassDecoration(L, info) {
                 const p = mapped.params[0];
                 const paramOk = p.kind === "classval" &&
                     (p.className === info.def.name ||
-                        (isSubclassOf(L, info.def.name, p.className) &&
+                        (isSubclassOf(lowerer, info.def.name, p.className) &&
                             (() => {
-                                const sup = L.classes.get(p.className);
-                                return sup !== undefined && !sup.generic && ctorAbiEquals(L, info, sup);
+                                const sup = lowerer.classes.get(p.className);
+                                return sup !== undefined && !sup.generic && ctorAbiEquals(lowerer, info, sup);
                             })()));
                 if (!paramOk) {
-                    L.unsupported("SC1090", d, `class decorators whose parameter is not the decorated class ('${display}' cannot flow into a '${L.fmt(p)}' slot — declare the parameter as 'typeof ${display}' or a base class sharing its constructor signature)`);
+                    lowerer.unsupported("SC1090", d, `class decorators whose parameter is not the decorated class ('${display}' cannot flow into a '${lowerer.fmt(p)}' slot — declare the parameter as 'typeof ${display}' or a base class sharing its constructor signature)`);
                 }
             }
             // The return: void/undefined keeps the original binding; the class
@@ -2292,17 +2270,17 @@ export function analyzeClassDecoration(L, info) {
             const replaces = ret.kind === "classval";
             if (replaces) {
                 const retOk = ret.className === info.def.name ||
-                    (isSubclassOf(L, ret.className, info.def.name) &&
+                    (isSubclassOf(lowerer, ret.className, info.def.name) &&
                         (() => {
-                            const sub = L.classes.get(ret.className);
-                            return sub !== undefined && !sub.generic && ctorAbiEquals(L, sub, info);
+                            const sub = lowerer.classes.get(ret.className);
+                            return sub !== undefined && !sub.generic && ctorAbiEquals(lowerer, sub, info);
                         })());
                 if (!retOk) {
-                    L.unsupported("SC1090", d, `class decorators returning '${L.fmt(ret)}' (a replacement must be '${display}' itself or a subclass sharing its constructor signature — tsc's structural check admits shapes the compiled nominal hierarchy cannot rebind)`);
+                    lowerer.unsupported("SC1090", d, `class decorators returning '${lowerer.fmt(ret)}' (a replacement must be '${display}' itself or a subclass sharing its constructor signature — tsc's structural check admits shapes the compiled nominal hierarchy cannot rebind)`);
                 }
             }
             else if (ret.kind !== "void") {
-                L.unsupported("SC1090", d, `class decorators returning '${L.fmt(ret)}' (supported returns: the decorated class type, a subclass with the same constructor signature, or void)`);
+                lowerer.unsupported("SC1090", d, `class decorators returning '${lowerer.fmt(ret)}' (supported returns: the decorated class type, a subclass with the same constructor signature, or void)`);
             }
             shapes.push({ kind: "call", funcType: mapped, replaces });
         }
@@ -2314,13 +2292,13 @@ export function analyzeClassDecoration(L, info) {
             // and namespace-nested declarations (the qualified-access paths
             // resolve the class directly, not through the rebound binding).
             if (info.subclasses.length > 0) {
-                L.unsupported("SC1090", cd.nodes[0], `class decorators that can replace a class with subclasses ('${info.subclasses[0].def.jsName ?? info.subclasses[0].def.name}' extends '${display}', but the runtime base would be the decoration result — return void, or decorate the leaf classes)`);
+                lowerer.unsupported("SC1090", cd.nodes[0], `class decorators that can replace a class with subclasses ('${info.subclasses[0].def.jsName ?? info.subclasses[0].def.name}' extends '${display}', but the runtime base would be the decoration result — return void, or decorate the leaf classes)`);
             }
             if (info.decl && !ts.isSourceFile(info.decl.parent)) {
-                L.unsupported("SC1090", cd.nodes[0], "class decorators that can replace a namespace-nested class (qualified references resolve the declaration directly — return void, or declare the class at top level)");
+                lowerer.unsupported("SC1090", cd.nodes[0], "class decorators that can replace a namespace-nested class (qualified references resolve the declaration directly — return void, or declare the class at top level)");
             }
             const globalId = `%g.dec.${info.def.name}`;
-            L.globalsList.push({
+            lowerer.globalsList.push({
                 id: globalId,
                 name: `${display}.decorated`,
                 type: { kind: "classval", className: info.def.name },
@@ -2345,7 +2323,7 @@ export function analyzeClassDecoration(L, info) {
    * object, each replacing decorator's non-undefined result feeding the
    * next application; the final value binds the class name (the mutable
    * classval global) when any decorator can replace. */
-export function lowerClassDecoration(L, info) {
+function lowerClassDecoration(lowerer, info) {
     const cd = info.classDecorators;
     if (!cd || cd.poisoned || cd.shapes === undefined || info.decl === null)
         return [];
@@ -2364,16 +2342,16 @@ export function lowerClassDecoration(L, info) {
             const d = cd.nodes[i];
             const shape = cd.shapes[i];
             if (shape.kind === "ambientThrow") {
-                stmts.push({ kind: "exprStmt", expr: nsUndefRead(L, shape.name, d, F64), loc: locOf(d) });
+                stmts.push({ kind: "exprStmt", expr: nsUndefRead(lowerer, shape.name, d, F64), loc: locOf(d) });
                 return stmts;
             }
-            const value = L.lowerExprExpecting(d.expression, shape.funcType);
-            const local = L.declareHiddenLocal("dec", shape.funcType);
+            const value = lowerer.lowerExprExpecting(d.expression, shape.funcType);
+            const local = lowerer.declareHiddenLocal("dec", shape.funcType);
             stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: locOf(d) });
             temps.push({ localId: local.id, funcType: shape.funcType, replaces: shape.replaces });
         }
         // 2. Applications, reverse order, over the accumulating class value.
-        let current = classValueRef(L, info, info.decl);
+        let current = classValueRef(lowerer, info, info.decl);
         for (let i = temps.length - 1; i >= 0; i--) {
             const t = temps[i];
             const dLoc = locOf(cd.nodes[i]);
@@ -2381,16 +2359,16 @@ export function lowerClassDecoration(L, info) {
             const args = [];
             if (t.funcType.params.length === 1) {
                 const p = t.funcType.params[0];
-                const widened = L.coerceToExpected(current, p);
-                L.requireExactShape(cd.nodes[i], widened.type, p);
+                const widened = lowerer.coerceToExpected(current, p);
+                lowerer.requireExactShape(cd.nodes[i], widened.type, p);
                 args.push(widened);
             }
             const call = { kind: "callValue", callee, args, type: t.funcType.ret, loc: dLoc };
             if (t.replaces) {
                 const target = { kind: "classval", className: info.def.name };
-                const widened = L.coerceToExpected(call, target);
-                L.requireExactShape(cd.nodes[i], widened.type, target);
-                const res = L.declareHiddenLocal("decres", target);
+                const widened = lowerer.coerceToExpected(call, target);
+                lowerer.requireExactShape(cd.nodes[i], widened.type, target);
+                const res = lowerer.declareHiddenLocal("decres", target);
                 stmts.push({ kind: "varDecl", localId: res.id, init: widened, loc: dLoc });
                 current = { kind: "varRef", localId: res.id, type: target, loc: dLoc };
             }
@@ -2407,8 +2385,8 @@ export function lowerClassDecoration(L, info) {
     catch (e) {
         if (!(e instanceof PoisonError))
             throw e;
-        L.stats.statementsFailed++;
-        L.bumpFileStat(loc.file, "failed");
+        lowerer.stats.statementsFailed++;
+        lowerer.bumpFileStat(loc.file, "failed");
         return [];
     }
 }
@@ -2416,7 +2394,7 @@ export function lowerClassDecoration(L, info) {
    * the compile-time prototype-chain walk (`D.x` reads C's global when C
    * declared x and nothing between redeclares it; a redeclaration shadows
    * with its OWN storage, exactly JS). */
-export function findStaticOn(L, info, name) {
+export function findStaticOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const field = c.staticFields.find((s) => s.name === name);
         if (field)
@@ -2431,15 +2409,15 @@ export function findStaticOn(L, info, name) {
    * the through-a-VALUE devirtualization test: a classval(info) slot can
    * hold any descendant, and a shadowing redeclaration means the runtime
    * class decides which storage answers. */
-export function staticShadowBelow(L, info, name) {
+export function staticShadowBelow(lowerer, info, name) {
     return info.subclasses.some((s) => s.staticFields.some((f) => f.name === name) ||
         s.staticMethods?.has(name) === true ||
         s.genericStatics?.has(name) === true ||
-        staticShadowBelow(L, s, name));
+        staticShadowBelow(lowerer, s, name));
 }
 /** The nearest GENERIC static declaration of `name` at/above `info` —
    * findStaticOn's twin over the genericStatics tables. */
-export function findGenericStaticOn(L, info, name) {
+export function findGenericStaticOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const gs = c.genericStatics?.get(name);
         if (gs)
@@ -2450,16 +2428,16 @@ export function findGenericStaticOn(L, info, name) {
 /** A static METHOD taken as a value: the zero-capture closure over its
    * module function — the declared-function-as-value rule verbatim
    * (interned by the backend, so `C.m === C.m` holds). */
-function staticMethodValue(L, declarer, name, sig, blame, loc) {
+function staticMethodValue(lowerer, declarer, name, sig, blame, loc) {
     const fnName = `%${declarer.def.name}.static:${name}`;
-    L.noteEdge(fnName);
+    lowerer.noteEdge(fnName);
     const funcType = {
         kind: "func",
         params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
         ret: sig.ret,
         ...(sig.params.some((p) => p.mode === "dynRest") ? { rest: true } : {}),
     };
-    L.requireExactArityValue(blame, blame, sig.params, funcType);
+    lowerer.requireExactArityValue(blame, blame, sig.params, funcType);
     return { kind: "closure", fnName, captures: [], type: funcType, loc };
 }
 /** The class itself taken as a VALUE (`const X = C`, an argument, an
@@ -2470,26 +2448,26 @@ function staticMethodValue(L, declarer, name, sig, blame, loc) {
    * constructor (Error/EventEmitter/stream chains complete their `new`
    * by special rules) — are named fences here. The constructor edge is
    * noted at every classRef: a value can always be constructed through. */
-export function classValueRef(L, info, blame) {
+export function classValueRef(lowerer, info, blame) {
     const display = info.def.name.replace(/^%|^%m\d+\./, "");
-    fenceDecorationThrows(L, info, blame);
+    fenceDecorationThrows(lowerer, info, blame);
     if (info.generic) {
         // `typeof Box` — the uninstantiated FAMILY as a value: no thunk, no
         // single constructor ABI. INSTANTIATIONS have class objects
         // (`const B = Box<number>`, `new (v: number) => Box<number>` slots).
-        L.unsupported("SC1090", blame, `generic classes as values ('typeof ${display}' keeps the type parameter — instantiation expressions ('${display}<number>') and concrete constructor-typed slots compile)`);
+        lowerer.unsupported("SC1090", blame, `generic classes as values ('typeof ${display}' keeps the type parameter — instantiation expressions ('${display}<number>') and concrete constructor-typed slots compile)`);
     }
     if (info.builtinError || info.builtinEmitter || info.builtinStream !== undefined) {
-        L.unsupported("SC1090", blame, `builtin classes as values ('${display}' is runtime-provided — reference program-declared classes instead)`);
+        lowerer.unsupported("SC1090", blame, `builtin classes as values ('${display}' is runtime-provided — reference program-declared classes instead)`);
     }
-    if (L.inheritsBuiltinErrorCtor(info) || L.inheritsBuiltinEmitterCtor(info) ||
-        inheritsBuiltinStreamCtor(L, info) ||
+    if (lowerer.inheritsBuiltinErrorCtor(info) || lowerer.inheritsBuiltinEmitterCtor(info) ||
+        inheritsBuiltinStreamCtor(lowerer, info) ||
         (() => { for (let c = info.base; c; c = c.base)
             if (c.builtinError || c.builtinEmitter || c.builtinStream !== undefined)
                 return true; return false; })()) {
-        L.unsupported("SC1090", blame, `classes extending builtin bases as values ('${display}' inherits a runtime-provided constructor)`);
+        lowerer.unsupported("SC1090", blame, `classes extending builtin bases as values ('${display}' inherits a runtime-provided constructor)`);
     }
-    L.noteEdge(`%${info.def.name}.constructor`);
+    lowerer.noteEdge(`%${info.def.name}.constructor`);
     return {
         kind: "classRef",
         className: info.def.name,
@@ -2502,7 +2480,7 @@ export function classValueRef(L, info, blame) {
    * constructor signature equals C's (same count, modes, and ABI types),
    * which is what keeps newValue completion against C's one signature
    * sound for every value legally in the slot. */
-export function ctorAbiEquals(L, sub, sup) {
+export function ctorAbiEquals(lowerer, sub, sup) {
     const a = sub.ctorParams;
     const b = sup.ctorParams;
     return a.length === b.length && a.every((p, i) => p.mode === b[i].mode && typeEquals(p.type, b[i].type));
@@ -2513,18 +2491,18 @@ export function ctorAbiEquals(L, sub, sup) {
    * compile-time name. Null for everything else — unresolved members
    * fall through to the ordinary chain so the static fence or the
    * generic member rejection names the site. */
-export function lowerStaticFieldRead(L, expr) {
+export function lowerStaticFieldRead(lowerer, expr) {
     if (expr.questionDotToken)
         return null;
     if (!ts.isIdentifier(expr.expression))
         return null;
-    const symbol = L.resolveValueSymbol(expr.expression);
-    const info = (symbol ? L.classBySymbol.get(symbol) : undefined) ??
+    const symbol = lowerer.resolveValueSymbol(expr.expression);
+    const info = (symbol ? lowerer.classBySymbol.get(symbol) : undefined) ??
         // A require binding over `module.exports = class {…}` (the alias
         // lands on the expression's own symbol): resolve/collect on demand,
         // or `C.name` below would fall through to paths that answer for
         // stdlib globals instead of this class.
-        propertyAssignedClassInfoOf(L, symbol) ??
+        propertyAssignedClassInfoOf(lowerer, symbol) ??
         undefined;
     if (!info)
         return null;
@@ -2536,27 +2514,27 @@ export function lowerStaticFieldRead(L, expr) {
     if (info.classDecorators?.valueGlobalId !== undefined)
         return null;
     const loc = locOf(expr);
-    const found = findStaticOn(L, info, expr.name.text);
+    const found = findStaticOn(lowerer, info, expr.name.text);
     // A #private static resolves only through the DECLARING class's own
     // name: in JS the brand lives on that one constructor object, so
     // `D.#s` (a subclass receiver) throws Node's TypeError instead of
     // reaching up the chain — fenced rather than silently resolved.
     if (found && expr.name.text.startsWith("#") && found.declarer !== info) {
-        L.unsupported("SC1090", expr, `reading the private static '${expr.name.text}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
+        lowerer.unsupported("SC1090", expr, `reading the private static '${expr.name.text}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
     }
     if (found?.field !== undefined) {
-        return L.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
     }
     if (found) {
-        return staticMethodValue(L, found.declarer, expr.name.text, found.method, expr, loc);
+        return staticMethodValue(lowerer, found.declarer, expr.name.text, found.method, expr, loc);
     }
     // A GENERIC static method as a VALUE: the pinned-value rule verbatim
     // (lowerGenericFnValue) — a slot spelling one concrete signature names
     // an instance, an unpinned reference fences by name.
     {
-        const gfound = findGenericStaticOn(L, info, expr.name.text);
+        const gfound = findGenericStaticOn(lowerer, info, expr.name.text);
         if (gfound)
-            return L.lowerGenericFnValue(expr, gfound.info);
+            return lowerer.lowerGenericFnValue(expr, gfound.info);
     }
     // `C.name` — the JS-observable class name, a compile-time constant on
     // the direct spelling (tsc rejects user statics named `name`, so the
@@ -2599,8 +2577,8 @@ function namedEvaluationName(expr) {
    * once. Statics-bearing expressions additionally restrict to positions
    * where "immediately before the enclosing statement" IS the evaluation
    * point (lowerFileInit drains pendingClassExprInits there). */
-export function lowerClassExpressionInfo(L, expr) {
-    const cached = L.exprClassInfoByNode.get(expr);
+export function lowerClassExpressionInfo(lowerer, expr) {
+    const cached = lowerer.exprClassInfoByNode.get(expr);
     if (cached)
         return cached;
     // Reentrancy guard: heritage resolution can DEMAND another class
@@ -2610,30 +2588,30 @@ export function lowerClassExpressionInfo(L, expr) {
     // can see (TS2506/TS2303 — direct, indirect, and cross-file require
     // cycles all probed); this fence is the backstop that turns anything
     // it misses into a diagnostic instead of a stack overflow.
-    if (L.collectingExprClasses.has(expr)) {
-        L.unsupported("SC1090", expr, "class expressions whose extends chain re-enters their own collection (a cyclic base through property assignments)");
+    if (lowerer.collectingExprClasses.has(expr)) {
+        lowerer.unsupported("SC1090", expr, "class expressions whose extends chain re-enters their own collection (a cyclic base through property assignments)");
     }
-    if (L.instantiationContext) {
-        L.unsupported("SC1090", expr, "class expressions inside generic functions (each instantiation would need its own class)");
+    if (lowerer.instantiationContext) {
+        lowerer.unsupported("SC1090", expr, "class expressions inside generic functions (each instantiation would need its own class)");
     }
     for (let p = expr.parent; !ts.isSourceFile(p); p = p.parent) {
         if (ts.isFunctionLike(p) || ts.isClassStaticBlockDeclaration(p)) {
-            L.unsupported("SC1090", expr, "class expressions inside functions (each evaluation creates a DISTINCT class in JS — fresh identity, fresh statics; declare the class at top level)");
+            lowerer.unsupported("SC1090", expr, "class expressions inside functions (each evaluation creates a DISTINCT class in JS — fresh identity, fresh statics; declare the class at top level)");
         }
     }
-    L.collectingExprClasses.add(expr);
+    lowerer.collectingExprClasses.add(expr);
     try {
-        L.collectClassShapeInner(expr, namedEvaluationName(expr));
+        lowerer.collectClassShapeInner(expr, namedEvaluationName(expr));
     }
     finally {
-        L.collectingExprClasses.delete(expr);
+        lowerer.collectingExprClasses.delete(expr);
     }
-    const info = L.classes.get(L.classNamer(expr));
+    const info = lowerer.classes.get(lowerer.classNamer(expr));
     if (!info)
         throw new PoisonError(); // collection poisoned and reported
-    L.exprClassInfoByNode.set(expr, info);
-    L.exprClasses.push(info);
-    L.onExprClassCollected?.(info);
+    lowerer.exprClassInfoByNode.set(expr, info);
+    lowerer.exprClasses.push(info);
+    lowerer.onExprClassCollected?.(info);
     // Static field initializers and static blocks run when the class
     // expression EVALUATES. The supported positions evaluate exactly once,
     // at the top-level statement containing the expression — the pending
@@ -2659,9 +2637,9 @@ export function lowerClassExpressionInfo(L, expr) {
                 ts.isSourceFile(holder.parent.parent)) ||
             (ts.isExpressionStatement(holder) && ts.isSourceFile(holder.parent));
         if (!wholeInit) {
-            L.unsupported("SC1090", expr, "class expressions with static initializers or static blocks outside a whole-initializer position (their declaration-time code must run exactly where the expression evaluates — bind the class in its own top-level `const C = class …` statement)");
+            lowerer.unsupported("SC1090", expr, "class expressions with static initializers or static blocks outside a whole-initializer position (their declaration-time code must run exactly where the expression evaluates — bind the class in its own top-level `const C = class …` statement)");
         }
-        L.pendingClassExprInits.push(...L.lowerStaticFieldInits(info));
+        lowerer.pendingClassExprInits.push(...lowerer.lowerStaticFieldInits(info));
     }
     return info;
 }
@@ -2673,20 +2651,20 @@ export function lowerClassExpressionInfo(L, expr) {
    * ReferenceError, so it lowers to exactly that read — every evaluation
    * throws identically, which is why the once-evaluated restriction and
    * the member fences don't apply. */
-export function lowerClassExpression(L, expr) {
+export function lowerClassExpression(lowerer, expr) {
     if (decoratorNodesOf(expr).length > 0 ||
         expr.members.some((m) => decoratorNodesOf(m).length > 0)) {
         if (!isJsSourceFile(expr.getSourceFile()) && expr.typeParameters === undefined) {
-            const thrown = guaranteedDecorationThrow(L, expr);
+            const thrown = guaranteedDecorationThrow(lowerer, expr);
             if (thrown) {
                 // The expression's static type never materializes — the read
                 // throws — so the nominal IR type only has to satisfy the
                 // consumer. F64 is the ambient-undefRead convention.
-                return nsUndefRead(L, thrown.name, expr, F64);
+                return nsUndefRead(lowerer, thrown.name, expr, F64);
             }
         }
     }
-    return classValueRef(L, lowerClassExpressionInfo(L, expr), expr);
+    return classValueRef(lowerer, lowerClassExpressionInfo(lowerer, expr), expr);
 }
 /** The EXACT class a receiver expression is statically known to BE (not
    * merely be typed by): the class name itself, or a `const` binding
@@ -2694,20 +2672,20 @@ export function lowerClassExpression(L, expr) {
    * can never hold a subclass at runtime, so static WRITES through them
    * hit the declaring class's storage exactly (the shadowing hazards of
    * general class values don't arise). Null for everything else. */
-export function exactClassOfReceiver(L, expr) {
+export function exactClassOfReceiver(lowerer, expr) {
     if (!ts.isIdentifier(expr))
         return null;
-    const symbol = L.resolveValueSymbol(expr);
+    const symbol = lowerer.resolveValueSymbol(expr);
     if (!symbol)
         return null;
-    const direct = L.classBySymbol.get(symbol);
+    const direct = lowerer.classBySymbol.get(symbol);
     // A rebindable decorated name is NOT exactly its class — the binding
     // may hold a replacing decorator's result (a subclass value), where a
     // static write would create an own property in JS. The general
     // class-value write fence answers instead.
     if (direct)
         return direct.classDecorators?.valueGlobalId !== undefined ? null : direct;
-    const decl = L.checker.valueDeclarationOf(symbol);
+    const decl = lowerer.checker.valueDeclarationOf(symbol);
     if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined ||
         !ts.isVariableDeclarationList(decl.parent) ||
         (decl.parent.flags & ts.NodeFlags.Const) === 0) {
@@ -2717,10 +2695,10 @@ export function exactClassOfReceiver(L, expr) {
     while (ts.isParenthesizedExpression(init))
         init = init.expression;
     if (ts.isClassExpression(init))
-        return L.exprClassInfoByNode.get(init) ?? null;
+        return lowerer.exprClassInfoByNode.get(init) ?? null;
     if (ts.isIdentifier(init)) {
-        const initSym = L.resolveValueSymbol(init);
-        const aliased = initSym ? (L.classBySymbol.get(initSym) ?? null) : null;
+        const initSym = lowerer.resolveValueSymbol(init);
+        const aliased = initSym ? (lowerer.classBySymbol.get(initSym) ?? null) : null;
         // `const X = C` over a rebindable decorated name: X holds the
         // decoration result — not exactly C (see the direct case above).
         return aliased?.classDecorators?.valueGlobalId !== undefined ? null : aliased;
@@ -2742,14 +2720,14 @@ export function exactClassOfReceiver(L, expr) {
    * fence names it. Collection is on demand and idempotent
    * (lowerClassExpressionInfo), so resolution order between files and
    * passes never matters. */
-export function propertyAssignedClassInfoOf(L, symbol) {
+export function propertyAssignedClassInfoOf(lowerer, symbol) {
     if (!symbol)
         return null;
-    const resolved = symbol.flags & ts.SymbolFlags.Alias ? L.checker.getAliasedSymbol(symbol) : symbol;
-    const registered = L.classBySymbol.get(resolved);
+    const resolved = symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol;
+    const registered = lowerer.classBySymbol.get(resolved);
     if (registered)
         return registered;
-    const decls = L.checker.declarationsOf(resolved);
+    const decls = lowerer.checker.declarationsOf(resolved);
     // The class expression's OWN symbol (tsgo's answer through CJS export
     // aliases): the declaration is the expression itself. Its top-level
     // assignment statement must be the binding's ONLY producer. The
@@ -2760,8 +2738,8 @@ export function propertyAssignedClassInfoOf(L, symbol) {
         const assign = enclosingTopLevelClassAssignment(decls[0]);
         if (!assign || countAssignmentsTo(assign) !== 1)
             return null;
-        const info = L.lowerClassExpressionInfo(decls[0]);
-        L.classBySymbol.set(resolved, info);
+        const info = lowerer.lowerClassExpressionInfo(decls[0]);
+        lowerer.classBySymbol.set(resolved, info);
         return info;
     }
     // The expando property symbol: every top-level `X.N = …` assignment is
@@ -2778,8 +2756,8 @@ export function propertyAssignedClassInfoOf(L, symbol) {
         rhs = rhs.expression;
     if (!ts.isClassExpression(rhs))
         return null;
-    const info = L.lowerClassExpressionInfo(rhs);
-    L.classBySymbol.set(resolved, info);
+    const info = lowerer.lowerClassExpressionInfo(rhs);
+    lowerer.classBySymbol.set(resolved, info);
     return info;
 }
 /** The top-level `… = <this class expression>` assignment a class
@@ -2830,7 +2808,7 @@ function countAssignmentsTo(assign) {
    * global and calls through the value. Null when the receiver isn't a
    * class name/value or the member doesn't resolve (the fences name the
    * site downstream). */
-export function lowerStaticMethodCall(L, call, access) {
+export function lowerStaticMethodCall(lowerer, call, access) {
     if (access.questionDotToken)
         return null;
     // `module.exports.describe()` in a module whose whole export IS a
@@ -2843,28 +2821,28 @@ export function lowerStaticMethodCall(L, call, access) {
         const whole = cjsClassExprWholeExportOf(access.getSourceFile());
         if (!whole)
             return null;
-        return staticCallOn(L, call, access, L.lowerClassExpressionInfo(whole.classExpr), false);
+        return staticCallOn(lowerer, call, access, lowerer.lowerClassExpressionInfo(whole.classExpr), false);
     }
-    const symbol = L.resolveValueSymbol(access.expression);
-    const direct = (symbol ? L.classBySymbol.get(symbol) : undefined) ??
+    const symbol = lowerer.resolveValueSymbol(access.expression);
+    const direct = (symbol ? lowerer.classBySymbol.get(symbol) : undefined) ??
         // A require binding over `module.exports = class {…}`: the alias
         // lands on the expression's own symbol — exact, like the name.
-        propertyAssignedClassInfoOf(L, symbol) ??
+        propertyAssignedClassInfoOf(lowerer, symbol) ??
         undefined;
     let info = direct ?? null;
     // A rebindable decorated name is a class VALUE receiver: the call
     // devirtualizes under the value rules (shadow fences below).
     let throughValue = direct?.classDecorators?.valueGlobalId !== undefined;
     if (!info) {
-        const recvT = L.mapTypeOf(L.typeOf(access.expression));
+        const recvT = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
         if (recvT?.kind !== "classval")
             return null;
-        info = L.classes.get(recvT.className) ?? null;
+        info = lowerer.classes.get(recvT.className) ?? null;
         throughValue = true;
     }
     if (!info)
         return null;
-    return staticCallOn(L, call, access, info, throughValue);
+    return staticCallOn(lowerer, call, access, info, throughValue);
 }
 /** True when a class-VALUE receiver can only hold `info`'s own class
    * object at runtime: the receiver provably IS the class
@@ -2876,10 +2854,10 @@ export function lowerStaticMethodCall(L, call, access) {
    * rebindable global). Exactly then a #private static access through
    * the value always carries the declaring class's brand — Node's
    * TypeError cannot arise. */
-function classValueIsExactlyOwn(L, recv, info) {
-    return exactClassOfReceiver(L, recv) === info || info.subclasses.length === 0;
+function classValueIsExactlyOwn(lowerer, recv, info) {
+    return exactClassOfReceiver(lowerer, recv) === info || info.subclasses.length === 0;
 }
-function staticCallOn(L, call, access, info, throughValue) {
+function staticCallOn(lowerer, call, access, info, throughValue) {
     const loc = locOf(call);
     // #private statics: through-a-VALUE receiver the call devirtualizes
     // exactly when the value can only BE the declaring class
@@ -2887,29 +2865,29 @@ function staticCallOn(L, call, access, info, throughValue) {
     // runtime fences, since only the declaring class object carries the
     // brand in JS), and the direct spelling resolves only on the
     // declaring class itself — `D.#s` is Node's TypeError.
-    if (access.name.text.startsWith("#") && throughValue && !classValueIsExactlyOwn(L, access.expression, info)) {
-        L.unsupported("SC1090", call, `calling the private static '${access.name.text}' through a class value (JS brands the declaring class object alone — call it through the class's own name)`);
+    if (access.name.text.startsWith("#") && throughValue && !classValueIsExactlyOwn(lowerer, access.expression, info)) {
+        lowerer.unsupported("SC1090", call, `calling the private static '${access.name.text}' through a class value (JS brands the declaring class object alone — call it through the class's own name)`);
     }
-    const found = findStaticOn(L, info, access.name.text);
+    const found = findStaticOn(lowerer, info, access.name.text);
     if (found && access.name.text.startsWith("#") && found.declarer !== info) {
-        L.unsupported("SC1090", call, `calling the private static '${access.name.text}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
+        lowerer.unsupported("SC1090", call, `calling the private static '${access.name.text}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
     }
     if (!found) {
         // GENERIC static methods: monomorphized like top-level generic
         // functions, called directly as `%C.static:m%n` — with the same
         // through-a-VALUE shadowing fence as plain statics.
-        const gfound = findGenericStaticOn(L, info, access.name.text);
+        const gfound = findGenericStaticOn(lowerer, info, access.name.text);
         if (!gfound)
             return null;
-        if (throughValue && staticShadowBelow(L, info, access.name.text)) {
-            L.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
+        if (throughValue && staticShadowBelow(lowerer, info, access.name.text)) {
+            lowerer.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
         }
-        const instance = genericCallInstance(L, call, gfound.info);
-        const args = L.completeArgs(call.arguments, instance.params, loc, call);
+        const instance = genericCallInstance(lowerer, call, gfound.info);
+        const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
         return { kind: "call", callee: instance.name, args, type: instance.returnType, loc };
     }
-    if (throughValue && staticShadowBelow(L, info, access.name.text)) {
-        L.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
+    if (throughValue && staticShadowBelow(lowerer, info, access.name.text)) {
+        lowerer.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
     }
     if (found.field !== undefined) {
         // A func-typed static field in call position: read the global,
@@ -2918,19 +2896,19 @@ function staticCallOn(L, call, access, info, throughValue) {
             return null;
         const callee = { kind: "varRef", localId: found.field.globalId, type: found.field.type, loc };
         const params = found.field.type.params;
-        const args = call.arguments.map((a, i) => L.lowerExprExpecting(a, params[i]));
+        const args = call.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
         for (let i = args.length; i < params.length; i++) {
-            const absent = omittedArgFor(L, params[i], loc);
+            const absent = omittedArgFor(lowerer, params[i], loc);
             if (!absent) {
-                L.unsupported("SC1090", call, "calls omitting a non-optional parameter of the callee's type");
+                lowerer.unsupported("SC1090", call, "calls omitting a non-optional parameter of the callee's type");
             }
             args.push(absent);
         }
         return { kind: "callValue", callee, args, type: found.field.type.ret, loc };
     }
     const fnName = `%${found.declarer.def.name}.static:${access.name.text}`;
-    L.noteEdge(fnName);
-    const args = L.completeArgs(call.arguments, found.method.params, loc, call);
+    lowerer.noteEdge(fnName);
+    const args = lowerer.completeArgs(call.arguments, found.method.params, loc, call);
     return { kind: "call", callee: fnName, args, type: found.method.ret, loc };
 }
 /** Static member access through a class VALUE (`X.m` where X is
@@ -2940,10 +2918,10 @@ function staticCallOn(L, call, access, info, throughValue) {
    * genuinely dynamic member: the class.name libCall reads the runtime
    * class object's stored name. Null when the receiver isn't a class
    * value or the member doesn't resolve. */
-export function lowerClassValueProperty(L, expr) {
+export function lowerClassValueProperty(lowerer, expr) {
     if (expr.questionDotToken)
         return null;
-    const recvT = L.mapTypeOf(L.typeOf(expr.expression));
+    const recvT = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
     if (recvT?.kind !== "classval")
         return null;
     const loc = locOf(expr);
@@ -2952,7 +2930,7 @@ export function lowerClassValueProperty(L, expr) {
     // genuinely dynamic member. It CONSUMES the receiver (no evaluation
     // is discarded), so any receiver expression is fine here.
     if (member === "name") {
-        const recv = L.lowerExpr(expr.expression);
+        const recv = lowerer.lowerExpr(expr.expression);
         if (recv.type.kind !== "classval")
             return null;
         return { kind: "libCall", fn: "class.name", args: [recv], type: STRING, loc };
@@ -2965,16 +2943,16 @@ export function lowerClassValueProperty(L, expr) {
         // Devirtualized reads DISCARD the receiver value, so only
         // side-effect-free receivers are claimed (the instanceOf fold
         // rule); computed ones meet the pointed fence with a bindable fix.
-        L.unsupported("SC1090", expr, "static member access through a computed class-value expression (bind the class value to a variable first)");
+        lowerer.unsupported("SC1090", expr, "static member access through a computed class-value expression (bind the class value to a variable first)");
     }
     // The direct class-name spelling resolved in lowerStaticFieldRead;
     // reaching here means the receiver is a classval-typed BINDING.
-    const info = L.classes.get(recvT.className);
+    const info = lowerer.classes.get(recvT.className);
     if (!info)
         return null;
-    const found = findStaticOn(L, info, member);
+    const found = findStaticOn(lowerer, info, member);
     if (!found) {
-        L.unsupported("SC1090", expr, `the static member '${member}' of class '${info.def.name.replace(/^%|^%m\d+\./, "")}' (static accessors and initializer-less static fields have no lowering, and Function members like .call/.bind/.prototype have no value form)`);
+        lowerer.unsupported("SC1090", expr, `the static member '${member}' of class '${info.def.name.replace(/^%|^%m\d+\./, "")}' (static accessors and initializer-less static fields have no lowering, and Function members like .call/.bind/.prototype have no value form)`);
     }
     // #private statics read through a class VALUE exactly when the value
     // can only BE the declaring class (classValueIsExactlyOwn — a const
@@ -2985,35 +2963,35 @@ export function lowerClassValueProperty(L, expr) {
     // lowerStaticFieldRead, so a private reaching here is a
     // classval-typed binding.
     if (member.startsWith("#")) {
-        if (!classValueIsExactlyOwn(L, expr.expression, info)) {
-            L.unsupported("SC1090", expr, `reading the private static '${member}' through a class value (JS brands the declaring class object alone — spell the declaring class's name)`);
+        if (!classValueIsExactlyOwn(lowerer, expr.expression, info)) {
+            lowerer.unsupported("SC1090", expr, `reading the private static '${member}' through a class value (JS brands the declaring class object alone — spell the declaring class's name)`);
         }
         if (found.declarer !== info) {
-            L.unsupported("SC1090", expr, `reading the private static '${member}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
+            lowerer.unsupported("SC1090", expr, `reading the private static '${member}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
         }
     }
-    if (staticShadowBelow(L, info, member)) {
-        L.unsupported("SC1090", expr, `reading the static member '${member}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
+    if (staticShadowBelow(lowerer, info, member)) {
+        lowerer.unsupported("SC1090", expr, `reading the static member '${member}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
     }
     if (found.field !== undefined) {
-        return L.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
+        return lowerer.maybeNarrow({ kind: "varRef", localId: found.field.globalId, type: found.field.type, loc }, expr);
     }
-    return staticMethodValue(L, found.declarer, member, found.method, expr, loc);
+    return staticMethodValue(lowerer, found.declarer, member, found.method, expr, loc);
 }
 /** An abstract method's signature — lambdaSignature minus the body check
    * (an abstract declaration IS exactly a signature; tsc rejects the
    * async/generator/generic-with-body combinations before this runs, and
    * the generic case fences at the caller). */
-function abstractMemberSignature(L, member) {
+function abstractMemberSignature(lowerer, member) {
     for (const param of member.parameters) {
         if (!ts.isIdentifier(param.name))
-            L.unsupported("SC1031", param);
+            lowerer.unsupported("SC1031", param);
     }
-    return { shapes: L.paramShapes(member.parameters), ret: L.declaredReturnType(member, member.name) };
+    return { shapes: lowerer.paramShapes(member.parameters), ret: lowerer.declaredReturnType(member, member.name) };
 }
 /** The nearest declaration of `name` at or above `info` — the method a
    * receiver of that static class runs when nothing below overrides it. */
-export function findMethodOn(L, info, name) {
+export function findMethodOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const sig = c.methods.get(name);
         if (sig)
@@ -3022,8 +3000,8 @@ export function findMethodOn(L, info, name) {
     return null;
 }
 /** True when `sub` is a STRICT descendant of `sup` in the class graph. */
-export function isSubclassOf(L, sub, sup) {
-    for (let c = L.classes.get(sub)?.base ?? null; c; c = c.base) {
+export function isSubclassOf(lowerer, sub, sup) {
+    for (let c = lowerer.classes.get(sub)?.base ?? null; c; c = c.base) {
         if (c.def.name === sup)
             return true;
     }
@@ -3032,7 +3010,7 @@ export function isSubclassOf(L, sub, sup) {
 /** In an extends-hierarchy (as base or derived): the class carries a
    * vtable and participates in dynamic instanceof; standalone classes keep
    * their exact pre-inheritance layout and behavior. */
-export function inHierarchy(L, info) {
+export function inHierarchy(lowerer, info) {
     // The runtime emitter class is ALWAYS a hierarchy member: ScrEmitter
     // carries its vtable word whether or not the program subclasses it
     // (the runtime allocates bare instances with scr_emitter_vt).
@@ -3043,15 +3021,15 @@ export function inHierarchy(L, info) {
    * class can reach a distinct implementation, so it must dispatch
    * dynamically. Abstract re-declarations don't count (they carry no
    * implementation; the concrete ones below them do, via the recursion). */
-export function overrideBelow(L, info, name) {
+export function overrideBelow(lowerer, info, name) {
     return info.subclasses.some((s) => {
         const m = s.methods.get(name);
-        return (m !== undefined && m.abstract !== true) || L.overrideBelow(s, name);
+        return (m !== undefined && m.abstract !== true) || lowerer.overrideBelow(s, name);
     });
 }
 /** The nearest GENERIC-method declaration of `name` at/above `info` —
    * findMethodOn's twin over the genericMethods tables. */
-export function findGenericMethodOn(L, info, name) {
+export function findGenericMethodOn(lowerer, info, name) {
     for (let c = info; c; c = c.base) {
         const gm = c.genericMethods?.get(name);
         if (gm)
@@ -3063,8 +3041,8 @@ export function findGenericMethodOn(L, info, name) {
    * method `name` — overrideBelow's twin: generic methods have no vtable
    * slot, so a call that could reach an override compiles only when the
    * receiver's runtime class is statically exact. */
-export function genericOverrideBelow(L, info, name) {
-    return info.subclasses.some((s) => s.genericMethods?.has(name) === true || genericOverrideBelow(L, s, name));
+function genericOverrideBelow(lowerer, info, name) {
+    return info.subclasses.some((s) => s.genericMethods?.has(name) === true || genericOverrideBelow(lowerer, s, name));
 }
 /** The receiver's EXACT runtime class, when the expression proves it: a
    * `new C(...)` expression directly, or a const binding initialized with
@@ -3072,23 +3050,23 @@ export function genericOverrideBelow(L, info, name) {
    * The class is read off the mapped INITIALIZER type — a `const b: Base =
    * new D()` receiver is exactly D, not its annotation. Distinct from
    * exactClassOfReceiver, which answers for CLASS-VALUE receivers. */
-export function exactInstanceClassOf(L, expr) {
+export function exactInstanceClassOf(lowerer, expr) {
     let e = expr;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
     const classOfNew = (n) => {
         if (!ts.isNewExpression(n))
             return null;
-        const t = L.mapTypeOf(L.typeOf(n));
-        return t?.kind === "object" ? (L.classes.get(t.className) ?? null) : null;
+        const t = lowerer.mapTypeOf(lowerer.typeOf(n));
+        return t?.kind === "object" ? (lowerer.classes.get(t.className) ?? null) : null;
     };
     const direct = classOfNew(e);
     if (direct)
         return direct;
     if (!ts.isIdentifier(e))
         return null;
-    const symbol = L.resolveValueSymbol(e);
-    const decl = symbol ? L.checker.valueDeclarationOf(symbol) : undefined;
+    const symbol = lowerer.resolveValueSymbol(e);
+    const decl = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
     if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined ||
         !ts.isVariableDeclarationList(decl.parent) ||
         (decl.parent.flags & ts.NodeFlags.Const) === 0) {
@@ -3111,7 +3089,7 @@ export function exactInstanceClassOf(L, expr) {
    * and uses that want the empty record width-coerce at the use site.
    * Const + direct `new` only — a reassignable binding or a produced
    * value keeps today's record story and its fences. */
-export function genericIfaceBindingKeepsClass(L, decl, declaredType) {
+export function genericIfaceBindingKeepsClass(lowerer, decl, declaredType) {
     if (declaredType.kind !== "record")
         return false;
     if (!ts.isIdentifier(decl.name) || decl.initializer === undefined || decl.type === undefined)
@@ -3123,14 +3101,14 @@ export function genericIfaceBindingKeepsClass(L, decl, declaredType) {
         init = init.expression;
     if (!ts.isNewExpression(init))
         return false;
-    const shape = L.shapes.get(declaredType.shapeId);
+    const shape = lowerer.shapes.get(declaredType.shapeId);
     if (!shape || shape.fields.length > 0 || shape.indexValue !== undefined || shape.tuple === true)
         return false;
-    const annT = L.typeOf(decl.name);
-    const props = L.checker.getPropertiesOfType(annT);
+    const annT = lowerer.typeOf(decl.name);
+    const props = lowerer.checker.getPropertiesOfType(annT);
     if (props.length === 0)
         return false;
-    return props.every((p) => isGenericCallableMemberType(L.checker.getTypeOfSymbol(p), L.checker));
+    return props.every((p) => isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(p), lowerer.checker));
 }
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
    * checker's resolved signature (type arguments substituted, inferred or
@@ -3140,14 +3118,14 @@ export function genericIfaceBindingKeepsClass(L, decl, declaredType) {
    * runtime class could OVERRIDE the method (genericOverrideBelow) must be
    * statically exact (exactInstanceClassOf) — the override set then
    * resolves at compile time — or fences by name. */
-export function lowerClassGenericMethodCall(L, call, access, recvInfo, found, recvIr) {
+export function lowerClassGenericMethodCall(lowerer, call, access, recvInfo, found, recvIr) {
     const name = access.name.text;
     let { declarer, info } = found;
-    if (genericOverrideBelow(L, recvInfo, name)) {
-        const exact = exactInstanceClassOf(L, access.expression);
-        const refound = exact ? findGenericMethodOn(L, exact, name) : null;
+    if (genericOverrideBelow(lowerer, recvInfo, name)) {
+        const exact = exactInstanceClassOf(lowerer, access.expression);
+        const refound = exact ? findGenericMethodOn(lowerer, exact, name) : null;
         if (!refound) {
-            L.unsupported("SC1090", call, `calling the generic method '${name}' through a receiver whose runtime class may override it (a subclass of '${recvInfo.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it and generic methods dispatch statically — bind the receiver to a const initialized with its 'new' expression)`);
+            lowerer.unsupported("SC1090", call, `calling the generic method '${name}' through a receiver whose runtime class may override it (a subclass of '${recvInfo.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it and generic methods dispatch statically — bind the receiver to a const initialized with its 'new' expression)`);
         }
         ({ declarer, info } = refound);
     }
@@ -3156,23 +3134,23 @@ export function lowerClassGenericMethodCall(L, call, access, recvInfo, found, re
     // type parameters); everything else about the dispatch — static
     // resolution, the exactness rule above — is the generic story.
     const instance = info.implicitParams
-        ? implicitCallInstance(L, call, info)
-        : genericCallInstance(L, call, info);
-    const receiver = recvIr ?? L.lowerExpr(access.expression);
+        ? implicitCallInstance(lowerer, call, info)
+        : genericCallInstance(lowerer, call, info);
+    const receiver = recvIr ?? lowerer.lowerExpr(access.expression);
     const loc = locOf(call);
     // The declarer sits at/above the receiver's static class on the plain
     // path; the EXACT path can land below it (a base-typed const provably
     // holding the subclass) — that direction is the checker-grade downcast
     // (the exactness proof is static, stronger than an instanceof guard).
-    const thisArg = receiver.type.kind === "object" && isSubclassOf(L, declarer.def.name, receiver.type.className)
+    const thisArg = receiver.type.kind === "object" && isSubclassOf(lowerer, declarer.def.name, receiver.type.className)
         ? { kind: "downcast", value: receiver, type: { kind: "object", className: declarer.def.name }, loc }
-        : upcastTo(L, receiver, declarer.def.name);
-    const args = L.completeArgs(call.arguments, instance.params, loc, call);
+        : upcastTo(lowerer, receiver, declarer.def.name);
+    const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
     return { kind: "call", callee: instance.name, args: [thisArg, ...args], type: instance.returnType, loc };
 }
 /** Wraps a derived-class expression in an upcast when the target base
    * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
-export function upcastTo(L, expr, className) {
+export function upcastTo(lowerer, expr, className) {
     if (expr.type.kind === "object" && expr.type.className !== className) {
         return { kind: "upcast", value: expr, type: { kind: "object", className }, loc: expr.loc };
     }
@@ -3190,14 +3168,14 @@ export function upcastTo(L, expr, className) {
  * and no other reference to the parameter — the one rest-constructor
  * form with an exact static story under monomorphization (the
  * instantiation adopts the base's ABI; see collectClassShapeInner). */
-function mixinForwardingCtor(L, ctor) {
+function mixinForwardingCtor(lowerer, ctor) {
     if (ctor.parameters.length !== 1 || !ctor.body)
         return false;
     const p = ctor.parameters[0];
     if (!p.dotDotDotToken || !ts.isIdentifier(p.name))
         return false;
     const paramName = p.name;
-    const paramSym = L.checker.getSymbolAtLocation(paramName);
+    const paramSym = lowerer.checker.getSymbolAtLocation(paramName);
     if (!paramSym)
         return false;
     const first = ctor.body.statements[0];
@@ -3212,13 +3190,13 @@ function mixinForwardingCtor(L, ctor) {
     if (!ts.isSpreadElement(a) || !ts.isIdentifier(a.expression))
         return false;
     const spreadIdent = a.expression;
-    if (L.checker.getSymbolAtLocation(spreadIdent) !== paramSym)
+    if (lowerer.checker.getSymbolAtLocation(spreadIdent) !== paramSym)
         return false;
     let extraRef = false;
     ts.walkPreorder(ctor.body, (n) => {
         if (n === spreadIdent)
             return undefined;
-        if (ts.isIdentifier(n) && n.text === paramName.text && L.checker.getSymbolAtLocation(n) === paramSym) {
+        if (ts.isIdentifier(n) && n.text === paramName.text && lowerer.checker.getSymbolAtLocation(n) === paramSym) {
             extraRef = true;
             return "stop";
         }
@@ -3226,7 +3204,7 @@ function mixinForwardingCtor(L, ctor) {
     });
     return !extraRef;
 }
-export function lowerClassMembers(L, info) {
+export function lowerClassMembers(lowerer, info) {
     const out = [];
     const className = info.def.name;
     // Generic-class INSTANTIATIONS (and mixin instantiations) are
@@ -3242,20 +3220,20 @@ export function lowerClassMembers(L, info) {
     // exists): the diagnostic is recorded — the member skips like a
     // signature-blocked function (lowerStaticMethod's rule) instead of
     // crashing the whole lowering.
-    if (!info.generic && (always || L.wantBody(`%${className}.constructor`))) {
+    if (!info.generic && (always || lowerer.wantBody(`%${className}.constructor`))) {
         try {
-            out.push(L.lowerClassCtor(info));
+            out.push(lowerer.lowerClassCtor(info));
         }
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
         }
     }
-    for (const { mName, member } of L.classMethodMembers(info)) {
-        if (!always && !L.wantBody(`%${className}.${mName}`))
+    for (const { mName, member } of lowerer.classMethodMembers(info)) {
+        if (!always && !lowerer.wantBody(`%${className}.${mName}`))
             continue;
         try {
-            const fn = L.lowerClassMethodMember(info, member);
+            const fn = lowerer.lowerClassMethodMember(info, member);
             if (fn)
                 out.push(fn);
         }
@@ -3265,15 +3243,15 @@ export function lowerClassMembers(L, info) {
         }
     }
     for (const name of info.staticMethods?.keys() ?? []) {
-        if (!L.wantBody(`%${className}.static:${name}`))
+        if (!lowerer.wantBody(`%${className}.static:${name}`))
             continue;
-        const fn = lowerStaticMethod(L, info, name);
+        const fn = lowerStaticMethod(lowerer, info, name);
         if (fn)
             out.push(fn);
     }
     for (const prop of info.throwingSetters) {
-        if (always || L.wantBody(`%${className}.set:${prop}`))
-            out.push(L.throwingSetterFn(info, prop));
+        if (always || lowerer.wantBody(`%${className}.set:${prop}`))
+            out.push(lowerer.throwingSetterFn(info, prop));
     }
     return out;
 }
@@ -3281,17 +3259,17 @@ export function lowerClassMembers(L, info) {
    * base class runs just its field initializers; a derived class inherits
    * the base's signature — forward every param to super(), then run own
    * field initializers. */
-export function lowerClassCtor(L, info) {
-    return withInstanceBindings(L, info, () => lowerClassCtorInner(L, info));
+export function lowerClassCtor(lowerer, info) {
+    return withInstanceBindings(lowerer, info, () => lowerClassCtorInner(lowerer, info));
 }
-function lowerClassCtorInner(L, info) {
+function lowerClassCtorInner(lowerer, info) {
     const className = info.def.name;
     const thisType = { kind: "object", className };
-    const prevClass = L.currentClass;
-    L.currentClass = info;
-    L.fnStack.push(newFnCtx(false, null, null, VOID));
+    const prevClass = lowerer.currentClass;
+    lowerer.currentClass = info;
+    lowerer.fnStack.push(newFnCtx(false, null, null, VOID));
     try {
-        const thisLocal = L.declareThis(thisType);
+        const thisLocal = lowerer.declareThis(thisType);
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
         const body = [];
         // The construction-relevant base: generic families are transparent
@@ -3306,17 +3284,17 @@ function lowerClassCtorInner(L, info) {
             const loc = locOf(info.ctor);
             const forward = info.ctorParams.map((shape, i) => {
                 const local = { id: `arg${i}.0`, name: `arg${i}`, type: shape.type, mutable: false };
-                L.ctx.locals.push(local);
+                lowerer.ctx.locals.push(local);
                 params.push({ localId: local.id, name: local.name, type: shape.type });
                 return { kind: "varRef", localId: local.id, type: shape.type, loc };
             });
-            body.push(...L.lowerDerivedCtorBody(info, thisLocal, forward));
+            body.push(...lowerer.lowerDerivedCtorBody(info, thisLocal, forward));
         }
         else if (info.ctor) {
             // The default-param prologue runs FIRST — before field initializers
             // and (in a derived class) before super(): JS evaluates parameter
             // defaults on entry, ahead of everything the body does.
-            const declared = L.declareParams(info.ctor.parameters, info.ctorParams);
+            const declared = lowerer.declareParams(info.ctor.parameters, info.ctorParams);
             params.push(...declared.params);
             body.push(...declared.prologue);
             if (!ctorBase) {
@@ -3324,13 +3302,13 @@ function lowerClassCtorInner(L, info) {
                 // of construction, the parameter-property assignments open the
                 // constructor body (probed — a field initializer reading a
                 // parameter property sees undefined).
-                body.push(...L.fieldInitStmts(info, thisLocal));
-                body.push(...paramPropInitStmts(L, info, thisLocal));
+                body.push(...lowerer.fieldInitStmts(info, thisLocal));
+                body.push(...paramPropInitStmts(lowerer, info, thisLocal));
                 if (info.ctor.body)
-                    body.push(...L.lowerStmts(info.ctor.body.statements));
+                    body.push(...lowerer.lowerStmts(info.ctor.body.statements));
             }
             else if (info.ctor.body) {
-                body.push(...L.lowerDerivedCtorBody(info, thisLocal));
+                body.push(...lowerer.lowerDerivedCtorBody(info, thisLocal));
             }
         }
         else {
@@ -3342,12 +3320,12 @@ function lowerClassCtorInner(L, info) {
                 const loc = locOf(info.decl);
                 const superArgs = info.ctorParams.map((shape, i) => {
                     const local = { id: `arg${i}.0`, name: `arg${i}`, type: shape.type, mutable: false };
-                    L.ctx.locals.push(local);
+                    lowerer.ctx.locals.push(local);
                     params.push({ localId: local.id, name: local.name, type: shape.type });
                     return { kind: "varRef", localId: local.id, type: shape.type, loc };
                 });
                 try {
-                    body.push(L.superCallStmt(info, thisLocal, superArgs, loc));
+                    body.push(lowerer.superCallStmt(info, thisLocal, superArgs, loc));
                 }
                 catch (e) {
                     // A synthesized super() can fence (a stream base whose
@@ -3357,20 +3335,20 @@ function lowerClassCtorInner(L, info) {
                         throw e;
                 }
             }
-            body.push(...L.fieldInitStmts(info, thisLocal));
+            body.push(...lowerer.fieldInitStmts(info, thisLocal));
         }
         return {
             name: `%${className}.constructor`,
             params,
             returnType: VOID,
-            locals: L.ctx.locals,
+            locals: lowerer.ctx.locals,
             body,
             loc: locOf(info.ctor ?? info.decl),
         };
     }
     finally {
-        L.fnStack.pop();
-        L.currentClass = prevClass;
+        lowerer.fnStack.pop();
+        lowerer.currentClass = prevClass;
     }
 }
 /** The lowered method-map name of a class member: identifier text, a
@@ -3382,7 +3360,7 @@ function lowerClassCtorInner(L, info) {
    * accessor "get:x" convention; for-of, spreads, and array destructuring
    * dispatch to it through the iterator protocol). Null for genuinely
    * runtime-keyed names — the computed-member fences stay. */
-export function classMemberNameOf(L, name) {
+export function classMemberNameOf(lowerer, name) {
     if (ts.isIdentifier(name))
         return name.text;
     // #private methods key by their spelled name ('#m') — '#' is
@@ -3394,37 +3372,37 @@ export function classMemberNameOf(L, name) {
     let e = name.expression;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
-    if (ts.isPropertyAccessExpression(e) && L.stdlibGlobalMember(e, "Symbol") === "iterator") {
+    if (ts.isPropertyAccessExpression(e) && lowerer.stdlibGlobalMember(e, "Symbol") === "iterator") {
         return "sym:iterator";
     }
-    return L.foldedStringKeyOf(name.expression);
+    return lowerer.foldedStringKeyOf(name.expression);
 }
-export function classIteratorOf(L, t) {
+export function classIteratorOf(lowerer, t) {
     if (t.kind !== "object")
         return null;
-    const info = L.classes.get(t.className);
+    const info = lowerer.classes.get(t.className);
     if (!info)
         return null;
-    const iter = findMethodOn(L, info, "sym:iterator");
+    const iter = findMethodOn(lowerer, info, "sym:iterator");
     if (!iter || iter.sig.params.length !== 0 || iter.sig.abstract === true)
         return null;
     const iterT = iter.sig.ret;
     if (iterT.kind !== "object")
         return null;
-    const itInfo = L.classes.get(iterT.className);
+    const itInfo = lowerer.classes.get(iterT.className);
     if (!itInfo)
         return null;
     // IteratorClose honesty: a declared return()/throw() would be called
     // by JS on abrupt completion; these desugars never close.
-    if (findMethodOn(L, itInfo, "return") || findMethodOn(L, itInfo, "throw"))
+    if (findMethodOn(lowerer, itInfo, "return") || findMethodOn(lowerer, itInfo, "throw"))
         return null;
-    const next = findMethodOn(L, itInfo, "next");
+    const next = findMethodOn(lowerer, itInfo, "next");
     if (!next || next.sig.params.length !== 0 || next.sig.abstract === true)
         return null;
     const resultT = next.sig.ret;
     if (resultT.kind !== "record")
         return null;
-    const shape = L.shapes.get(resultT.shapeId);
+    const shape = lowerer.shapes.get(resultT.shapeId);
     const value = shape?.fields.find((f) => f.name === "value");
     if (!shape || !value)
         return null;
@@ -3435,12 +3413,12 @@ export function classIteratorOf(L, t) {
 }
 /** The `it.next()` step of a class iterator as an ordinary (possibly
    * virtual) method call. */
-export function classIteratorNextCall(L, cit, itRef, loc) {
-    return accessorCall(L, cit.iterT.className, "next", itRef, [], cit.resultT, loc);
+export function classIteratorNextCall(lowerer, cit, itRef, loc) {
+    return accessorCall(lowerer, cit.iterT.className, "next", itRef, [], cit.resultT, loc);
 }
 /** `recv[Symbol.iterator]()` as an ordinary method call. */
-export function classIteratorOpenCall(L, cit, recv, loc) {
-    return accessorCall(L, cit.className, "sym:iterator", recv, [], cit.iterT, loc);
+export function classIteratorOpenCall(lowerer, cit, recv, loc) {
+    return accessorCall(lowerer, cit.className, "sym:iterator", recv, [], cit.iterT, loc);
 }
 /** `[...new C]` / `f(...new C)` over a CLASS ITERABLE: the eager drain —
    * an interned `%iter.drain.<n>(recv)` lifted function running the
@@ -3451,23 +3429,23 @@ export function classIteratorOpenCall(L, cit, recv, loc) {
    * `(number | symbol)[]`) pushes each value wrapped into its arm. Null
    * when the value isn't a recognized class iterable or the element
    * doesn't coerce — spread fences stay. */
-export function classIteratorDrainCall(L, src, loc, elemT) {
-    const cit = classIteratorOf(L, src.type);
+export function classIteratorDrainCall(lowerer, src, loc, elemT) {
+    const cit = classIteratorOf(lowerer, src.type);
     if (!cit)
         return null;
     const outElem = elemT ?? cit.valueT;
     // Probe the element coercion purely: identical types, or an arm of a
     // union destination (the wrap coerceToExpected applies below).
     if (!typeEquals(outElem, cit.valueT)) {
-        if (outElem.kind !== "union" || L.armTag(outElem.unionId, cit.valueT) < 0)
+        if (outElem.kind !== "union" || lowerer.armTag(outElem.unionId, cit.valueT) < 0)
             return null;
     }
     const outT = arrayOf(outElem);
     const key = `${cit.className}:${typeKey(outElem)}`;
-    let name = L.iterDrainHelpers.get(key);
+    let name = lowerer.iterDrainHelpers.get(key);
     if (!name) {
-        name = `%iter.drain.${L.iterDrainHelpers.size}`;
-        L.iterDrainHelpers.set(key, name);
+        name = `%iter.drain.${lowerer.iterDrainHelpers.size}`;
+        lowerer.iterDrainHelpers.set(key, name);
         const recvT = { kind: "object", className: cit.className };
         const recvRef = { kind: "varRef", localId: "r.0", type: recvT, loc };
         const itRef = { kind: "varRef", localId: "it.0", type: cit.iterT, loc };
@@ -3475,7 +3453,7 @@ export function classIteratorDrainCall(L, src, loc, elemT) {
         const resRef = { kind: "varRef", localId: "res.0", type: cit.resultT, loc };
         const valueRead = { kind: "recordGet", obj: resRef, shapeId: cit.resultT.shapeId, field: "value", type: cit.valueT, loc };
         const loop = [
-            { kind: "varDecl", localId: "res.0", init: classIteratorNextCall(L, cit, itRef, loc), loc },
+            { kind: "varDecl", localId: "res.0", init: classIteratorNextCall(lowerer, cit, itRef, loc), loc },
             ...(cit.hasDone
                 ? [
                     {
@@ -3493,14 +3471,14 @@ export function classIteratorDrainCall(L, src, loc, elemT) {
                     kind: "arrIntrinsic",
                     method: "push",
                     receiver: outRef,
-                    args: [L.coerceToExpected(valueRead, outElem)],
+                    args: [lowerer.coerceToExpected(valueRead, outElem)],
                     type: F64,
                     loc,
                 },
                 loc,
             },
         ];
-        L.liftedFns.push({
+        lowerer.liftedFns.push({
             name,
             params: [{ localId: "r.0", name: "r", type: recvT }],
             returnType: outT,
@@ -3512,7 +3490,7 @@ export function classIteratorDrainCall(L, src, loc, elemT) {
             ],
             body: [
                 { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: outT, loc }, loc },
-                { kind: "varDecl", localId: "it.0", init: classIteratorOpenCall(L, cit, recvRef, loc), loc },
+                { kind: "varDecl", localId: "it.0", init: classIteratorOpenCall(lowerer, cit, recvRef, loc), loc },
                 {
                     kind: "while",
                     cond: { kind: "boolLit", value: true, type: BOOL, loc },
@@ -3535,18 +3513,18 @@ export function classIteratorDrainCall(L, src, loc, elemT) {
 /** The tail of a class iterable's protocol from an already-open ITERATOR
    * object (`var [a, ...rest] = new C` — the rest element drains whatever
    * next() still yields): the drain loop keyed by the iterator class. */
-export function classIteratorRestDrainCall(L, cit, itVal, loc) {
+export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
     const outT = arrayOf(cit.valueT);
     const key = `it:${cit.iterT.className}`;
-    let name = L.iterDrainHelpers.get(key);
+    let name = lowerer.iterDrainHelpers.get(key);
     if (!name) {
-        name = `%iter.drain.${L.iterDrainHelpers.size}`;
-        L.iterDrainHelpers.set(key, name);
+        name = `%iter.drain.${lowerer.iterDrainHelpers.size}`;
+        lowerer.iterDrainHelpers.set(key, name);
         const itRef = { kind: "varRef", localId: "it.0", type: cit.iterT, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: outT, loc };
         const resRef = { kind: "varRef", localId: "res.0", type: cit.resultT, loc };
         const loop = [
-            { kind: "varDecl", localId: "res.0", init: classIteratorNextCall(L, cit, itRef, loc), loc },
+            { kind: "varDecl", localId: "res.0", init: classIteratorNextCall(lowerer, cit, itRef, loc), loc },
             ...(cit.hasDone
                 ? [
                     {
@@ -3571,7 +3549,7 @@ export function classIteratorRestDrainCall(L, cit, itVal, loc) {
                 loc,
             },
         ];
-        L.liftedFns.push({
+        lowerer.liftedFns.push({
             name,
             params: [{ localId: "it.0", name: "it", type: cit.iterT }],
             returnType: outT,
@@ -3597,13 +3575,13 @@ export function classIteratorRestDrainCall(L, cit, itVal, loc) {
 /** One method or accessor body as its module function `%C.name`
    * (accessors are methods with property syntax: "get:x"/"set:x" entries —
    * see collectClassShape). */
-export function lowerClassMethodMember(L, info, fnLike) {
-    return withInstanceBindings(L, info, () => lowerClassMethodMemberInner(L, info, fnLike));
+export function lowerClassMethodMember(lowerer, info, fnLike) {
+    return withInstanceBindings(lowerer, info, () => lowerClassMethodMemberInner(lowerer, info, fnLike));
 }
-function lowerClassMethodMemberInner(L, info, fnLike) {
+function lowerClassMethodMemberInner(lowerer, info, fnLike) {
     const className = info.def.name;
     const thisType = { kind: "object", className };
-    const memberName = ts.isMethodDeclaration(fnLike) ? classMemberNameOf(L, fnLike.name) : ts.isIdentifier(fnLike.name) || ts.isPrivateIdentifier(fnLike.name) ? fnLike.name.text : null;
+    const memberName = ts.isMethodDeclaration(fnLike) ? classMemberNameOf(lowerer, fnLike.name) : ts.isIdentifier(fnLike.name) || ts.isPrivateIdentifier(fnLike.name) ? fnLike.name.text : null;
     if (memberName === null)
         return null;
     const mName = ts.isMethodDeclaration(fnLike)
@@ -3612,8 +3590,8 @@ function lowerClassMethodMemberInner(L, info, fnLike) {
     const sig = info.methods.get(mName);
     if (!sig || !fnLike.body)
         return null;
-    const prevClass = L.currentClass;
-    L.currentClass = info;
+    const prevClass = lowerer.currentClass;
+    lowerer.currentClass = info;
     // ASYNC methods: the module function is an async IrFunction — its
     // body returns the promise's INNER type (a `return v` fulfills with
     // v) and every call enters through the emitted fiber spawn wrapper
@@ -3630,26 +3608,26 @@ function lowerClassMethodMemberInner(L, info, fnLike) {
     const bodyReturn = isAsync && sig.ret.kind === "promise"
         ? sig.ret.inner
         : genCh !== null
-            ? L.genBodyReturnType(sig.ret)
+            ? lowerer.genBodyReturnType(sig.ret)
             : sig.ret;
     const fnCtx = newFnCtx(false, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
     if (genCh !== null)
         fnCtx.generator = genCh;
-    L.fnStack.push(fnCtx);
+    lowerer.fnStack.push(fnCtx);
     try {
-        const thisLocal = L.declareThis(thisType);
+        const thisLocal = lowerer.declareThis(thisType);
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
         // `this` is declared first, so method parameter DEFAULTS may use it
         // (JS allows this in method defaults; it is param 0 here).
-        const declared = L.declareParams(fnLike.parameters, sig.params);
+        const declared = lowerer.declareParams(fnLike.parameters, sig.params);
         params.push(...declared.params);
-        const body = [...declared.prologue, ...L.lowerStmts(fnLike.body.statements)];
+        const body = [...declared.prologue, ...lowerer.lowerStmts(fnLike.body.statements)];
         const fn = {
             name: `%${className}.${mName}`,
             params,
             returnType: bodyReturn,
-            locals: L.ctx.locals,
+            locals: lowerer.ctx.locals,
             body,
             loc: locOf(fnLike),
         };
@@ -3660,8 +3638,8 @@ function lowerClassMethodMemberInner(L, info, fnLike) {
         return fn;
     }
     finally {
-        L.fnStack.pop();
-        L.currentClass = prevClass;
+        lowerer.fnStack.pop();
+        lowerer.currentClass = prevClass;
     }
 }
 /** One static method body as its module function `%C.static:m` — an
@@ -3671,22 +3649,10 @@ function lowerClassMethodMemberInner(L, info, fnLike) {
    * named fences, with arrow functions transparent (they inherit the
    * method's `this`) and this-binding function forms opaque — the static-
    * block rule verbatim. */
-export function lowerStaticMethod(L, info, name) {
+export function lowerStaticMethod(lowerer, info, name) {
     const entry = info.staticMethods?.get(name);
     if (!entry?.member.body)
         return null;
-    const checkThis = (n) => {
-        if (ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n) ||
-            ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n) ||
-            ts.isGetAccessor(n) || ts.isSetAccessor(n) ||
-            ts.isClassDeclaration(n) || ts.isClassExpression(n)) {
-            return;
-        }
-        if (n.kind === ts.SyntaxKind.ThisKeyword || n.kind === ts.SyntaxKind.SuperKeyword) {
-            L.unsupported("SC1090", n, `'${n.kind === ts.SyntaxKind.ThisKeyword ? "this" : "super"}' in static methods (it names the RECEIVER class — a dynamic value; reference the class by name instead)`);
-        }
-        n.forEachChild(checkThis);
-    };
     // Async statics: an async IrFunction like any module function — the
     // body returns the promise's INNER type, calls enter through the
     // fiber spawn wrapper (callTargetC routes by fn.async).
@@ -3695,16 +3661,16 @@ export function lowerStaticMethod(L, info, name) {
     const bodyReturn = isAsync && entry.ret.kind === "promise" ? entry.ret.inner : entry.ret;
     const fnCtx = newFnCtx(false, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
-    L.fnStack.push(fnCtx);
+    lowerer.fnStack.push(fnCtx);
     try {
-        entry.member.body.forEachChild(checkThis);
-        const declared = L.declareParams(entry.member.parameters, entry.params);
-        const body = [...declared.prologue, ...L.lowerStmts(entry.member.body.statements)];
+        rejectStaticThis(lowerer, entry.member.body, (keyword) => `'${keyword}' in static methods (it names the RECEIVER class — a dynamic value; reference the class by name instead)`);
+        const declared = lowerer.declareParams(entry.member.parameters, entry.params);
+        const body = [...declared.prologue, ...lowerer.lowerStmts(entry.member.body.statements)];
         const fn = {
             name: `%${info.def.name}.static:${name}`,
             params: declared.params,
             returnType: bodyReturn,
-            locals: L.ctx.locals,
+            locals: lowerer.ctx.locals,
             body,
             loc: locOf(entry.member),
         };
@@ -3722,7 +3688,7 @@ export function lowerStaticMethod(L, info, name) {
         return null;
     }
     finally {
-        L.fnStack.pop();
+        lowerer.fnStack.pop();
     }
 }
 /** A synthesized throwing setter: a getter-only override shadows the
@@ -3730,7 +3696,7 @@ export function lowerStaticMethod(L, info, name) {
    * throw exactly like Node's TypeError — a real instance (a typed catch's
    * `e instanceof TypeError` matches), catchable, exit 1 uncaught (message
    * text is compiler-worded; stdout and exit code are the contract). */
-export function throwingSetterFn(L, info, prop) {
+export function throwingSetterFn(lowerer, info, prop) {
     const className = info.def.name;
     const thisType = { kind: "object", className };
     const sig = info.methods.get(`set:${prop}`);
@@ -3773,23 +3739,23 @@ export function throwingSetterFn(L, info, prop) {
    * null when the generic class extends nothing, exactly the source's
    * story (tsc forbids super() there). Ordinary classes answer their base
    * unchanged. */
-export function superBaseOf(info) {
+function superBaseOf(info) {
     const b = info.base;
     return b?.generic ? b.base : b;
 }
 /** The class's OWN field initializers as fieldSet statements (declaration
    * order) — a base constructor's prologue, a derived constructor's
    * super()-return continuation. */
-export function fieldInitStmts(L, info, thisLocal) {
+export function fieldInitStmts(lowerer, info, thisLocal) {
     const out = [];
     const thisType = { kind: "object", className: info.def.name };
     for (const f of info.fieldOrder) {
         if (!f.initializer)
             continue;
-        L.stats.statementsTotal++;
-        L.bumpFileStat(locOf(f.initializer).file, "total");
+        lowerer.stats.statementsTotal++;
+        lowerer.bumpFileStat(locOf(f.initializer).file, "total");
         try {
-            const value = L.lowerExprExpecting(f.initializer, f.type);
+            const value = lowerer.lowerExprExpecting(f.initializer, f.type);
             out.push({
                 kind: "fieldSet",
                 obj: { kind: "varRef", localId: thisLocal.id, type: thisType, loc: locOf(f.initializer) },
@@ -3802,8 +3768,8 @@ export function fieldInitStmts(L, info, thisLocal) {
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
-            L.stats.statementsFailed++;
-            L.bumpFileStat(locOf(f.initializer).file, "failed");
+            lowerer.stats.statementsFailed++;
+            lowerer.bumpFileStat(locOf(f.initializer).file, "failed");
         }
     }
     return out;
@@ -3817,16 +3783,16 @@ export function fieldInitStmts(L, info, thisLocal) {
    * Each assignment reads the parameter's BODY local (defaults already
    * applied by the declareParams prologue), whose type the collection made
    * the field's type — slot-exact by construction. */
-export function paramPropInitStmts(L, info, thisLocal) {
+function paramPropInitStmts(lowerer, info, thisLocal) {
     const out = [];
     const thisType = { kind: "object", className: info.def.name };
     for (const pp of info.paramProps ?? []) {
         const loc = locOf(pp.param);
-        const local = ts.isIdentifier(pp.param.name) ? L.resolveLocal(pp.param.name) : null;
+        const local = ts.isIdentifier(pp.param.name) ? lowerer.resolveLocal(pp.param.name) : null;
         if (!local || !typeEquals(local.type, pp.type)) {
             // Defensive: collection derived the field type from the same
             // paramShape the ctor's declareParams bound — they cannot diverge.
-            L.unsupported("SC1090", pp.param, "this parameter property form");
+            lowerer.unsupported("SC1090", pp.param, "this parameter property form");
         }
         out.push({
             kind: "fieldSet",
@@ -3846,7 +3812,7 @@ export function paramPropInitStmts(L, info, thisLocal) {
    * guarantees a super call exists and runs before any this-use; the
    * supported form is a top-level expression statement — anywhere else
    * (conditionals, expression positions) is rejected, not misordered. */
-export function lowerDerivedCtorBody(L, info, thisLocal, 
+export function lowerDerivedCtorBody(lowerer, info, thisLocal, 
 /** Mixin forwarding-constructor mode: `super(...args)` forwards these
  * pre-declared synthetic params directly (the spread never lowers —
  * the base's ABI is this constructor's ABI). */
@@ -3860,49 +3826,49 @@ forward) {
             ? stmt.expression
             : null;
         if (!superCall) {
-            out.push(...L.lowerStmts([stmt]));
+            out.push(...lowerer.lowerStmts([stmt]));
             continue;
         }
-        if (!L.suppressStats) {
-            L.stats.statementsTotal++;
-            L.bumpFileStat(locOf(stmt).file, "total");
+        if (!lowerer.suppressStats) {
+            lowerer.stats.statementsTotal++;
+            lowerer.bumpFileStat(locOf(stmt).file, "total");
         }
         try {
             if (superSeen)
-                L.unsupported("SC1090", stmt, "multiple super() calls");
+                lowerer.unsupported("SC1090", stmt, "multiple super() calls");
             superSeen = true;
             const base = superBaseOf(info);
             if (base.builtinEmitter && superCall.arguments.length > 0) {
                 // @types/node admits super({ captureRejections }) — no lowering.
-                L.unsupported("SC1090", superCall, "EventEmitter constructor options ('captureRejections')");
+                lowerer.unsupported("SC1090", superCall, "EventEmitter constructor options ('captureRejections')");
             }
             if (base.builtinStream) {
                 // super(options?) into a runtime stream base: the stream spoke
                 // parses the options and binds overridden underscore methods.
-                out.push(...lowerStreamSuperCall(L, info, base, superCall.arguments, thisLocal, locOf(stmt), stmt));
-                out.push(...L.fieldInitStmts(info, thisLocal));
-                out.push(...paramPropInitStmts(L, info, thisLocal));
+                out.push(...lowerStreamSuperCall(lowerer, info, base, superCall.arguments, thisLocal, locOf(stmt), stmt));
+                out.push(...lowerer.fieldInitStmts(info, thisLocal));
+                out.push(...paramPropInitStmts(lowerer, info, thisLocal));
                 continue;
             }
             const args = forward !== undefined
                 ? forward
                 : base.builtinError
-                    ? [L.errorMessageArg(superCall.arguments, locOf(stmt), stmt)]
+                    ? [lowerer.errorMessageArg(superCall.arguments, locOf(stmt), stmt)]
                     : base.builtinEmitter
                         ? []
-                        : L.completeArgs(superCall.arguments, base.ctorParams, locOf(stmt), stmt);
-            out.push(L.superCallStmt(info, thisLocal, args, locOf(stmt)));
+                        : lowerer.completeArgs(superCall.arguments, base.ctorParams, locOf(stmt), stmt);
+            out.push(lowerer.superCallStmt(info, thisLocal, args, locOf(stmt)));
             // super() returns → field initializers → parameter-property
             // assignments (Node's order, probed) → the rest of the body.
-            out.push(...L.fieldInitStmts(info, thisLocal));
-            out.push(...paramPropInitStmts(L, info, thisLocal));
+            out.push(...lowerer.fieldInitStmts(info, thisLocal));
+            out.push(...paramPropInitStmts(lowerer, info, thisLocal));
         }
         catch (e) {
             if (!(e instanceof PoisonError))
                 throw e;
-            if (!L.suppressStats) {
-                L.stats.statementsFailed++;
-                L.bumpFileStat(locOf(stmt).file, "failed");
+            if (!lowerer.suppressStats) {
+                lowerer.stats.statementsFailed++;
+                lowerer.bumpFileStat(locOf(stmt).file, "failed");
             }
         }
     }
@@ -3910,14 +3876,14 @@ forward) {
         // tsc guarantees the call exists somewhere; if it wasn't a top-level
         // statement the per-site rejection above already fired — this is the
         // constructor-level backstop so a half-initialized ctor never emits.
-        L.pushDiag(unsupportedDiag("SC1090", locOf(info.ctor), "super() calls anywhere but as a top-level constructor statement"));
+        lowerer.pushDiag(unsupportedDiag("SC1090", locOf(info.ctor), "super() calls anywhere but as a top-level constructor statement"));
     }
     return out;
 }
 /** `super(args)` → direct call of the base constructor with the SAME
    * `this` (upcast; retained by the varRef read — the callee owns and
    * releases its param per the universal convention). */
-export function superCallStmt(L, info, thisLocal, args, loc) {
+export function superCallStmt(lowerer, info, thisLocal, args, loc) {
     const base = superBaseOf(info);
     const thisRef = {
         kind: "varRef",
@@ -3935,7 +3901,7 @@ export function superCallStmt(L, info, thisLocal, args, loc) {
             expr: {
                 kind: "libCall",
                 fn: "error.ctor",
-                args: [L.upcastTo(thisRef, base.def.name), ...args],
+                args: [lowerer.upcastTo(thisRef, base.def.name), ...args],
                 type: VOID,
                 loc,
             },
@@ -3952,7 +3918,7 @@ export function superCallStmt(L, info, thisLocal, args, loc) {
             expr: {
                 kind: "libCall",
                 fn: "emitter.ctor",
-                args: [L.upcastTo(thisRef, base.def.name)],
+                args: [lowerer.upcastTo(thisRef, base.def.name)],
                 type: VOID,
                 loc,
             },
@@ -3964,15 +3930,15 @@ export function superCallStmt(L, info, thisLocal, args, loc) {
         // super() with default options (underscore methods still bind; a
         // construction passing options requires a declared constructor —
         // lowerNew fences that). Zero options ⇒ exactly one init stmt.
-        return lowerStreamSuperCall(L, info, base, [], thisLocal, loc, info.decl ?? info.ctor)[0];
+        return lowerStreamSuperCall(lowerer, info, base, [], thisLocal, loc, info.decl ?? info.ctor)[0];
     }
-    L.noteEdge(`%${base.def.name}.constructor`);
+    lowerer.noteEdge(`%${base.def.name}.constructor`);
     return {
         kind: "exprStmt",
         expr: {
             kind: "call",
             callee: `%${base.def.name}.constructor`,
-            args: [L.upcastTo(thisRef, base.def.name), ...args],
+            args: [lowerer.upcastTo(thisRef, base.def.name), ...args],
             type: VOID,
             loc,
         },
@@ -3982,37 +3948,37 @@ export function superCallStmt(L, info, thisLocal, args, loc) {
 /** `super.method(args)`: the base chain's implementation, called
    * DIRECTLY over this method's own `this` (upcast to the declarer) —
    * super dispatch is static in JS too, never through the dynamic class. */
-export function lowerSuperMethodCall(L, call, access) {
-    const cls = L.currentClass;
+export function lowerSuperMethodCall(lowerer, call, access) {
+    const cls = lowerer.currentClass;
     if (!cls?.base) {
         // tsc rejects super outside derived-class bodies first; defensive.
-        L.unsupported("SC1090", access, "'super' outside a derived class");
+        lowerer.unsupported("SC1090", access, "'super' outside a derived class");
     }
     // An emit-override SPECIALIZATION body's forward — `super.emit(event,
     // ...args)` — carries no literal event name; the specialization's own
     // context answers it (matched before any lookup: neither identifier
     // resolves through the ordinary lowering).
-    const forward = emitSpecSuperForward(L, call, access);
+    const forward = emitSpecSuperForward(lowerer, call, access);
     if (forward)
         return forward;
-    const found = L.findMethodOn(cls.base, access.name.text);
+    const found = lowerer.findMethodOn(cls.base, access.name.text);
     if (!found) {
         // `super.m(...)` of a GENERIC method: super dispatch is static in JS
         // too, so the base chain's declaration answers unconditionally — the
         // ordinary instantiation route over this method's own `this`.
-        const gfound = findGenericMethodOn(L, cls.base, access.name.text);
+        const gfound = findGenericMethodOn(lowerer, cls.base, access.name.text);
         if (gfound) {
-            const thisL = L.resolveThis();
+            const thisL = lowerer.resolveThis();
             if (!thisL)
-                L.unsupported("SC1080", access);
-            const instance = genericCallInstance(L, call, gfound.info);
+                lowerer.unsupported("SC1080", access);
+            const instance = genericCallInstance(lowerer, call, gfound.info);
             const loc = locOf(call);
             const thisRef = { kind: "varRef", localId: thisL.id, type: thisL.type, loc };
-            const args = L.completeArgs(call.arguments, instance.params, loc, call);
+            const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
             return {
                 kind: "call",
                 callee: instance.name,
-                args: [L.upcastTo(thisRef, gfound.declarer.def.name), ...args],
+                args: [lowerer.upcastTo(thisRef, gfound.declarer.def.name), ...args],
                 type: instance.returnType,
                 loc,
             };
@@ -4023,43 +3989,43 @@ export function lowerSuperMethodCall(L, call, access) {
         // spoke lowers with this method's own `this` as the receiver (an
         // emit override at-or-below `cls` never answers; the nearest one
         // strictly above does).
-        if (EMITTER_API_MEMBERS.has(access.name.text) && emitterRooted(L, cls.base)) {
-            const viaEmitter = lowerEmitterSuperCall(L, call, access, cls);
+        if (EMITTER_API_MEMBERS.has(access.name.text) && emitterRooted(lowerer, cls.base)) {
+            const viaEmitter = lowerEmitterSuperCall(lowerer, call, access, cls);
             if (viaEmitter)
                 return viaEmitter;
         }
-        L.unsupported("SC1090", access, `'super.${access.name.text}' (no base class declares it)`);
+        lowerer.unsupported("SC1090", access, `'super.${access.name.text}' (no base class declares it)`);
     }
     // tsc rejects super-access of abstract members (TS2513); defensive —
     // no function exists behind an abstract declaration.
     if (found.sig.abstract === true) {
-        L.unsupported("SC1090", access, `'super.${access.name.text}' of an abstract method`);
+        lowerer.unsupported("SC1090", access, `'super.${access.name.text}' of an abstract method`);
     }
-    const thisLocal = L.resolveThis();
+    const thisLocal = lowerer.resolveThis();
     if (!thisLocal)
-        L.unsupported("SC1080", access);
-    L.noteEdge(`%${found.declarer.def.name}.${access.name.text}`);
+        lowerer.unsupported("SC1080", access);
+    lowerer.noteEdge(`%${found.declarer.def.name}.${access.name.text}`);
     const loc = locOf(call);
     const thisRef = { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc };
-    const args = L.completeArgs(call.arguments, found.sig.params, loc, call);
+    const args = lowerer.completeArgs(call.arguments, found.sig.params, loc, call);
     return {
         kind: "call",
         callee: `%${found.declarer.def.name}.${access.name.text}`,
-        args: [L.upcastTo(thisRef, found.declarer.def.name), ...args],
+        args: [lowerer.upcastTo(thisRef, found.declarer.def.name), ...args],
         type: found.sig.ret,
         loc,
     };
 }
 /** The `this` reference for super accessor reads/writes, with the shared
    * validity checks (derived-class body, resolvable this). */
-export function superThisRef(L, access) {
-    const cls = L.currentClass;
+export function superThisRef(lowerer, access) {
+    const cls = lowerer.currentClass;
     if (!cls?.base) {
-        L.unsupported("SC1090", access, "'super' outside a derived class");
+        lowerer.unsupported("SC1090", access, "'super' outside a derived class");
     }
-    const thisLocal = L.resolveThis();
+    const thisLocal = lowerer.resolveThis();
     if (!thisLocal)
-        L.unsupported("SC1080", access);
+        lowerer.unsupported("SC1080", access);
     const loc = locOf(access);
     return {
         thisRef: { kind: "varRef", localId: thisLocal.id, type: thisLocal.type, loc },
@@ -4069,49 +4035,49 @@ export function superThisRef(L, access) {
 /** `super.x` read: a DIRECT call of the base chain's getter over this
    * method's own `this` (upcast to the declarer) — like super.method(),
    * never through the vtable. */
-export function lowerSuperAccessorRead(L, access) {
-    const { thisRef, base } = L.superThisRef(access);
+export function lowerSuperAccessorRead(lowerer, access) {
+    const { thisRef, base } = lowerer.superThisRef(access);
     const name = access.name.text;
-    const found = L.findMethodOn(base, `get:${name}`);
+    const found = lowerer.findMethodOn(base, `get:${name}`);
     if (!found) {
-        L.unsupported("SC1090", access, L.findMethodOn(base, name)
+        lowerer.unsupported("SC1090", access, lowerer.findMethodOn(base, name)
             ? `bound method references through 'super' (call 'super.${name}(...)' directly)`
             : `'super.${name}' (only base-class methods and getter properties are readable through 'super')`);
     }
     // tsc rejects super-access of abstract members (TS2513); defensive.
     if (found.sig.abstract === true) {
-        L.unsupported("SC1090", access, `'super.${name}' of an abstract accessor`);
+        lowerer.unsupported("SC1090", access, `'super.${name}' of an abstract accessor`);
     }
-    L.noteEdge(`%${found.declarer.def.name}.get:${name}`);
+    lowerer.noteEdge(`%${found.declarer.def.name}.get:${name}`);
     return {
         kind: "call",
         callee: `%${found.declarer.def.name}.get:${name}`,
-        args: [L.upcastTo(thisRef, found.declarer.def.name)],
+        args: [lowerer.upcastTo(thisRef, found.declarer.def.name)],
         type: found.sig.ret,
         loc: locOf(access),
     };
 }
 /** `super.x = v`: a DIRECT call of the base chain's setter (same
    * static-dispatch rule as every super member access). */
-export function lowerSuperAccessorWrite(L, access, rhs, loc) {
-    const { thisRef, base } = L.superThisRef(access);
+export function lowerSuperAccessorWrite(lowerer, access, rhs, loc) {
+    const { thisRef, base } = lowerer.superThisRef(access);
     const name = access.name.text;
-    const found = L.findMethodOn(base, `set:${name}`);
+    const found = lowerer.findMethodOn(base, `set:${name}`);
     if (!found) {
-        L.unsupported("SC1090", access, `assignment to 'super.${name}' (no base class declares a setter for it)`);
+        lowerer.unsupported("SC1090", access, `assignment to 'super.${name}' (no base class declares a setter for it)`);
     }
     // tsc rejects super-access of abstract members (TS2513); defensive.
     if (found.sig.abstract === true) {
-        L.unsupported("SC1090", access, `assignment to 'super.${name}' of an abstract accessor`);
+        lowerer.unsupported("SC1090", access, `assignment to 'super.${name}' of an abstract accessor`);
     }
-    L.noteEdge(`%${found.declarer.def.name}.set:${name}`);
-    const value = L.lowerExprExpecting(rhs, found.sig.params[0].type);
+    lowerer.noteEdge(`%${found.declarer.def.name}.set:${name}`);
+    const value = lowerer.lowerExprExpecting(rhs, found.sig.params[0].type);
     return {
         kind: "exprStmt",
         expr: {
             kind: "call",
             callee: `%${found.declarer.def.name}.set:${name}`,
-            args: [L.upcastTo(thisRef, found.declarer.def.name), value],
+            args: [lowerer.upcastTo(thisRef, found.declarer.def.name), value],
             type: VOID,
             loc,
         },
@@ -4122,7 +4088,7 @@ export function lowerSuperAccessorWrite(L, access, rhs, loc) {
    * inherited through ctor-less bases — is a builtin error class's. Such
    * classes construct with the error message rule, and their synthesized
    * constructors forward one plain string to error.ctor. */
-export function inheritsBuiltinErrorCtor(L, info) {
+export function inheritsBuiltinErrorCtor(lowerer, info) {
     for (let c = info; c; c = c.base) {
         if (c.builtinError)
             return true;
@@ -4133,7 +4099,7 @@ export function inheritsBuiltinErrorCtor(L, info) {
 }
 /** The EventEmitter twin: a ctor-less chain into the emitter base
    * inherits `new C()` — zero arguments (the options bag fences). */
-export function inheritsBuiltinEmitterCtor(L, info) {
+export function inheritsBuiltinEmitterCtor(lowerer, info) {
     for (let c = info; c; c = c.base) {
         if (c.builtinStream)
             return false; // the stream story owns the chain
@@ -4149,7 +4115,7 @@ export function inheritsBuiltinEmitterCtor(L, info) {
    * super() with default options; passing options through an inherited
    * constructor would need the literal at the new-site to plumb, so it
    * asks for a declared constructor instead). */
-export function inheritsBuiltinStreamCtor(L, info) {
+function inheritsBuiltinStreamCtor(lowerer, info) {
     for (let c = info; c; c = c.base) {
         if (c.builtinStream)
             return true;
@@ -4164,19 +4130,19 @@ export function inheritsBuiltinStreamCtor(L, info) {
  * super() call: "" when omitted or explicitly undefined (Node's message
  * property default), the string otherwise. The lib signature's second
  * parameter (options/cause) has no lowering. */
-export function errorMessageArg(L, args, loc, blame) {
+export function errorMessageArg(lowerer, args, loc, blame) {
     if (args.length > 1) {
-        L.unsupported("SC1090", args[1] ?? blame, "Error constructor options ('cause')");
+        lowerer.unsupported("SC1090", args[1] ?? blame, "Error constructor options ('cause')");
     }
     if (args.length === 0)
         return { kind: "strLit", value: "", type: STRING, loc };
-    const value = L.lowerExpr(args[0]);
+    const value = lowerer.lowerExpr(args[0]);
     if (value.type.kind === "string")
         return value;
     if (value.kind === "unitLit" && value.unit === "undefined") {
         return { kind: "strLit", value: "", type: STRING, loc };
     }
-    L.unsupported("SC1090", args[0], `Error messages of type '${L.fmt(value.type)}' (the message must be a string)`);
+    lowerer.unsupported("SC1090", args[0], `Error messages of type '${lowerer.fmt(value.type)}' (the message must be a string)`);
 }
 /** `new C(...)` of a registered PROGRAM class — the shared tail of the
  * identifier and namespace-qualified construction forms. */
@@ -4184,48 +4150,48 @@ export function errorMessageArg(L, args, loc, blame) {
  * class resolves to the INSTANTIATION the expression's checker type names
  * (inference and explicit type arguments both land there; defaults apply).
  * The identity function for ordinary classes. */
-function genericNewTarget(L, expr, info) {
+function genericNewTarget(lowerer, expr, info) {
     if (!info.generic)
         return info;
-    const t = L.typeOf(expr);
-    const mapped = L.mapTypeOf(t);
-    const instInfo = mapped?.kind === "object" ? L.classes.get(mapped.className) : undefined;
+    const t = lowerer.typeOf(expr);
+    const mapped = lowerer.mapTypeOf(t);
+    const instInfo = mapped?.kind === "object" ? lowerer.classes.get(mapped.className) : undefined;
     // Unmappable type arguments (or a poisoned instantiation): the site
     // reports the type it cannot compile — the instantiation's own
     // diagnostic (context-tagged) already told the deeper story.
     if (!instInfo || instInfo.generic)
-        L.badType(expr, t);
+        lowerer.badType(expr, t);
     return instInfo;
 }
 /** A class whose decoration provably throws has no reachable VALUE form:
  * the binding never initializes (the %init ReferenceError unwinds first),
  * so `new`, the class as a value, and `extends` all fence — reaching one
  * in compiled code would require executing past the throw. */
-export function fenceDecorationThrows(L, info, blame) {
+function fenceDecorationThrows(lowerer, info, blame) {
     if (info.decorationThrows === undefined)
         return;
-    L.unsupported("SC1090", blame, `using the class '${info.def.jsName || info.def.name}' whose decoration provably throws ('${info.decorationThrows.name}' is an ambient name nothing defines — the class statement crashes before the binding exists)`);
+    lowerer.unsupported("SC1090", blame, `using the class '${info.def.jsName || info.def.name}' whose decoration provably throws ('${info.decorationThrows.name}' is an ambient name nothing defines — the class statement crashes before the binding exists)`);
 }
-function lowerProgramClassNew(L, expr, info0, loc) {
-    const info = genericNewTarget(L, expr, info0);
-    fenceDecorationThrows(L, info, expr);
-    L.noteEdge(`%${info.def.name}.constructor`);
+function lowerProgramClassNew(lowerer, expr, declaredInfo, loc) {
+    const info = genericNewTarget(lowerer, expr, declaredInfo);
+    fenceDecorationThrows(lowerer, info, expr);
+    lowerer.noteEdge(`%${info.def.name}.constructor`);
     // A ctor-less chain into an EventEmitter base inherits `new C()` —
     // zero arguments (the options bag fences, like the super() form).
     // Stream subclasses come first: their chain roots at the emitter
     // too, but the message should name the stream story.
-    if (inheritsBuiltinStreamCtor(L, info) && (expr.arguments ?? []).length > 0) {
-        L.noLowering(`new ${info.def.name.replace(/^%/, "")} with arguments through an inherited stream constructor`, expr.arguments[0], "declare a constructor that passes an inline options object to super(...)");
+    if (inheritsBuiltinStreamCtor(lowerer, info) && (expr.arguments ?? []).length > 0) {
+        lowerer.noLowering(`new ${info.def.name.replace(/^%/, "")} with arguments through an inherited stream constructor`, expr.arguments[0], "declare a constructor that passes an inline options object to super(...)");
     }
-    if (L.inheritsBuiltinEmitterCtor(info) && (expr.arguments ?? []).length > 0) {
-        L.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
+    if (lowerer.inheritsBuiltinEmitterCtor(info) && (expr.arguments ?? []).length > 0) {
+        lowerer.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
     }
     // A ctor-less chain into a builtin error base inherits `new
     // C(message?)` — completed by the error rule (one plain string),
     // not the general ABI completion.
-    const args = L.inheritsBuiltinErrorCtor(info)
-        ? [L.errorMessageArg(expr.arguments ?? [], loc, expr)]
-        : L.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
+    const args = lowerer.inheritsBuiltinErrorCtor(info)
+        ? [lowerer.errorMessageArg(expr.arguments ?? [], loc, expr)]
+        : lowerer.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
     return {
         kind: "new",
         className: info.def.name,
@@ -4234,18 +4200,18 @@ function lowerProgramClassNew(L, expr, info0, loc) {
         loc,
     };
 }
-export function lowerNew(L, expr) {
+export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
     // `new X(...)` where X is a package-declared class, in a static build:
     // the per-package requires-dynamic diagnostic (the constructor runs in
     // the embedded engine). Under --dynamic, X is jsval-typed and lowers
     // to the construct op below.
-    if (!L.dynamic) {
+    if (!lowerer.dynamic) {
         const pkg = ts.isIdentifier(expr.expression)
-            ? L.npmPackageOfSymbol(L.resolveValueSymbol(expr.expression) ?? undefined)
+            ? lowerer.npmPackageOfSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)
             : null;
         if (pkg) {
-            L.pushDiag(requiresDynamicPackageDiag(pkg, loc));
+            lowerer.pushDiag(requiresDynamicPackageDiag(pkg, loc));
             throw new PoisonError();
         }
     }
@@ -4253,23 +4219,23 @@ export function lowerNew(L, expr) {
     // or any 'any'-typed constructor value) runs JS_CallConstructor —
     // `new Command()` is the npm entry point. Arguments marshal in; the
     // instance stays an island handle.
-    if (L.isIslandExpr(expr.expression)) {
-        const callee = L.lowerExpr(expr.expression);
-        const args = (expr.arguments ?? []).map((a) => L.jsvalIn(L.lowerExpr(a), a));
+    if (lowerer.isIslandExpr(expr.expression)) {
+        const callee = lowerer.lowerExpr(expr.expression);
+        const args = (expr.arguments ?? []).map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
         return { kind: "jsOp", op: "construct", args: [callee, ...args], type: JSVAL, loc };
     }
     // `new events.EventEmitter()` — the namespace-member (and CJS
     // `require('events').EventEmitter`) construction form: the property's
     // symbol resolves to the same ambient class as the named import.
     if (ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.name)) {
-        const memberSym = L.checker.getSymbolAtLocation(expr.expression.name);
+        const memberSym = lowerer.checker.getSymbolAtLocation(expr.expression.name);
         const resolved = memberSym && memberSym.flags & ts.SymbolFlags.Alias
-            ? L.checker.getAliasedSymbol(memberSym)
+            ? lowerer.checker.getAliasedSymbol(memberSym)
             : memberSym;
-        const emitterInfo = L.builtinEmitterInfoOf(resolved);
+        const emitterInfo = lowerer.builtinEmitterInfoOf(resolved);
         if (emitterInfo) {
             if ((expr.arguments ?? []).length > 0) {
-                L.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
+                lowerer.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
             }
             return {
                 kind: "libCall",
@@ -4281,41 +4247,41 @@ export function lowerNew(L, expr) {
         }
         // `new stream.Readable({...})` — the namespace-member (and CJS
         // `require('stream').Readable`) construction form.
-        const streamInfoNs = builtinStreamInfoOf(L, resolved);
+        const streamInfoNs = builtinStreamInfoOf(lowerer, resolved);
         if (streamInfoNs)
-            return lowerStreamNew(L, expr, streamInfoNs);
+            return lowerStreamNew(lowerer, expr, streamInfoNs);
         // `new N.C(...)` / `new a.Point(...)` — construction through a
         // USER namespace qualifier (import= alias chains included): the
         // member resolves to the registered program class, guarded by the
         // namespace source-order fences (lower-namespaces.ts).
-        if (!expr.expression.questionDotToken && nsMemberIdentOf(L, expr.expression)) {
+        if (!expr.expression.questionDotToken && nsMemberIdentOf(lowerer, expr.expression)) {
             if (memberSym)
-                fenceEarlyNsMemberRef(L, expr.expression, memberSym);
+                fenceEarlyNsMemberRef(lowerer, expr.expression, memberSym);
             // resolveValueSymbol (not the bare alias chase): the reference
             // must flush deferred collection diagnostics like any other.
-            const classSym = L.resolveValueSymbol(expr.expression.name);
-            const info = classSym ? L.classBySymbol.get(classSym) : undefined;
+            const classSym = lowerer.resolveValueSymbol(expr.expression.name);
+            const info = classSym ? lowerer.classBySymbol.get(classSym) : undefined;
             // Qualified spellings of a rebindable decorated class (an import=
             // alias chain landing on it) cannot construct the declaration
             // directly — the decoration result decides. The bare-name path
             // routes through the class VALUE; the qualified one fences.
             if (info?.classDecorators?.valueGlobalId !== undefined) {
-                L.unsupported("SC1090", expr, "constructing a decorated class through a qualified name (a replacing decorator rebinds the class name — construct through the bare name)");
+                lowerer.unsupported("SC1090", expr, "constructing a decorated class through a qualified name (a replacing decorator rebinds the class name — construct through the bare name)");
             }
             if (info)
-                return lowerProgramClassNew(L, expr, info, loc);
-            L.unsupported("SC1090", expr, `constructing '${expr.expression.name.text}' (a namespace member with no class lowering)`);
+                return lowerProgramClassNew(lowerer, expr, info, loc);
+            lowerer.unsupported("SC1090", expr, `constructing '${expr.expression.name.text}' (a namespace member with no class lowering)`);
         }
         // `new B.C()` where B is an AMBIENT namespace (fundule merges
         // included): Node evaluates the callee first and throws
         // ReferenceError before any argument runs — undefRead reproduces it
         // exactly.
         if (!expr.expression.questionDotToken) {
-            const ambientRoot = ambientNsRootOf(L, expr.expression.expression);
+            const ambientRoot = ambientNsRootOf(lowerer, expr.expression.expression);
             if (ambientRoot !== null) {
-                const t = ambientUndefReadType(L, expr);
+                const t = ambientUndefReadType(lowerer, expr);
                 if (t)
-                    return nsUndefRead(L, ambientRoot.text, expr, t);
+                    return nsUndefRead(lowerer, ambientRoot.text, expr, t);
             }
         }
         // Construction through a CJS export member tsgo types `any`
@@ -4331,9 +4297,9 @@ export function lowerNew(L, expr) {
                 (isModuleExportsAccess(expr.expression.expression) ||
                     (ts.isIdentifier(expr.expression.expression) &&
                         expr.expression.expression.text === "exports" &&
-                        !L.peekLocal(expr.expression.expression) &&
-                        !L.globalOf(expr.expression.expression)))) ||
-                L.cjsLocalModuleBindingOf(expr.expression.expression))) {
+                        !lowerer.peekLocal(expr.expression.expression) &&
+                        !lowerer.globalOf(expr.expression.expression)))) ||
+                lowerer.cjsLocalModuleBindingOf(expr.expression.expression))) {
             // Candidate symbols for the export global: the member symbol as
             // spelled, its alias-chased resolution (resolveValueSymbol carries
             // the dep-module fallback tsgo needs at member-use sites), and the
@@ -4341,28 +4307,28 @@ export function lowerNew(L, expr) {
             const candidates = [
                 memberSym,
                 resolved,
-                L.resolveValueSymbol(expr.expression.name) ?? undefined,
-                L.cjsModuleExportSymbol(expr.getSourceFile(), expr.expression.name.text),
+                lowerer.resolveValueSymbol(expr.expression.name) ?? undefined,
+                lowerer.cjsModuleExportSymbol(expr.getSourceFile(), expr.expression.name.text),
             ];
             const exportSym = candidates.find((s) => s !== undefined);
             const g = candidates
-                .map((s) => (s ? L.globalsBySymbol.get(s) : undefined))
+                .map((s) => (s ? lowerer.globalsBySymbol.get(s) : undefined))
                 .find((x) => x !== undefined);
             if (g && g.type.kind === "classval") {
-                const info = L.classes.get(g.type.className) ??
-                    propertyAssignedClassInfoOf(L, exportSym) ??
-                    L.classes.get(g.type.className);
+                const info = lowerer.classes.get(g.type.className) ??
+                    propertyAssignedClassInfoOf(lowerer, exportSym) ??
+                    lowerer.classes.get(g.type.className);
                 if (info && !info.generic) {
-                    L.noteEdge(`%${info.def.name}.constructor`);
+                    lowerer.noteEdge(`%${info.def.name}.constructor`);
                     const below = (c) => {
                         for (const s of c.subclasses) {
-                            L.noteEdge(`%${s.def.name}.constructor`);
+                            lowerer.noteEdge(`%${s.def.name}.constructor`);
                             below(s);
                         }
                     };
                     below(info);
                     const callee = { kind: "varRef", localId: g.id, type: g.type, loc };
-                    const args = L.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
+                    const args = lowerer.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
                     return {
                         kind: "newValue",
                         callee,
@@ -4378,7 +4344,7 @@ export function lowerNew(L, expr) {
     // of http.createServer (Node's Server class IS the factory's
     // product); routed to lower-server ahead of the stdlib-ctor fences.
     {
-        const httpServer = lowerHttpServerNew(L, expr);
+        const httpServer = lowerHttpServerNew(lowerer, expr);
         if (httpServer)
             return httpServer;
     }
@@ -4386,20 +4352,20 @@ export function lowerNew(L, expr) {
     // handle (lower-server): getName/destroy/counters through the dyn
     // handle ops, requests thread it via the agent option.
     {
-        const agent = lowerHttpAgentNew(L, expr);
+        const agent = lowerHttpAgentNew(lowerer, expr);
         if (agent)
             return agent;
     }
     if (ts.isIdentifier(expr.expression)) {
         // `import C = N.C; new C()` — the alias's own source-order guards
         // (a no-op for every non-import= binding).
-        fenceEarlyAliasUse(L, expr.expression, expr);
-        const symbol = L.resolveValueSymbol(expr.expression);
+        fenceEarlyAliasUse(lowerer, expr.expression, expr);
+        const symbol = lowerer.resolveValueSymbol(expr.expression);
         // `new Error(msg?)` (and TypeError/RangeError/SyntaxError): the
         // runtime-provided classes construct through one libCall — the result
         // TYPE names which builtin, and the message completes to "" exactly
         // like Node's message property default.
-        const errInfo = L.builtinErrorInfoOf(symbol);
+        const errInfo = lowerer.builtinErrorInfoOf(symbol);
         // `new DOMException(message?, nameOrOptions?)`: both arguments cross
         // as dyn values (absent → the dyn undefined), and the runtime owns
         // WebIDL's resolution — ToString of the message ("" for undefined),
@@ -4409,18 +4375,18 @@ export function lowerNew(L, expr) {
         if (errInfo && errInfo.def.name === "%DOMException") {
             const args = expr.arguments ?? [];
             if (args.length > 2) {
-                L.noLowering(`new DOMException with ${args.length} arguments`, expr);
+                lowerer.noLowering(`new DOMException with ${args.length} arguments`, expr);
             }
             const toDynArg = (a) => {
                 if (!a)
                     return dynUndefinedExpr(loc);
-                const v = L.lowerExpr(a);
+                const v = lowerer.lowerExpr(a);
                 if (v.type.kind === "dyn")
                     return v;
-                if (v.kind === "unitLit" || (v.type.kind !== "jsval" && L.dynConvertible(v.type))) {
+                if (v.kind === "unitLit" || (v.type.kind !== "jsval" && lowerer.dynConvertible(v.type))) {
                     return { kind: "dynFrom", value: v, type: DYN, loc };
                 }
-                L.noLowering(`new DOMException with a '${L.fmt(v.type)}' argument`, a, "message strings and string/options-object names lower (Node ToStrings other values — convert explicitly)");
+                lowerer.noLowering(`new DOMException with a '${lowerer.fmt(v.type)}' argument`, a, "message strings and string/options-object names lower (Node ToStrings other values — convert explicitly)");
             };
             const msgArg = toDynArg(args[0]);
             const nameArg = toDynArg(args[1]);
@@ -4433,7 +4399,7 @@ export function lowerNew(L, expr) {
             };
         }
         if (errInfo) {
-            const msg = L.errorMessageArg(expr.arguments ?? [], loc, expr);
+            const msg = lowerer.errorMessageArg(expr.arguments ?? [], loc, expr);
             return {
                 kind: "libCall",
                 fn: "error.new",
@@ -4445,10 +4411,10 @@ export function lowerNew(L, expr) {
         // `new EventEmitter()`: the runtime-provided emitter constructs
         // through one libCall. Zero arguments — the options bag
         // (@types/node's captureRejections) has no lowering.
-        const emitterInfo = L.builtinEmitterInfoOf(symbol);
+        const emitterInfo = lowerer.builtinEmitterInfoOf(symbol);
         if (emitterInfo) {
             if ((expr.arguments ?? []).length > 0) {
-                L.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
+                lowerer.unsupported("SC1090", expr.arguments[0], "EventEmitter constructor options ('captureRejections')");
             }
             return {
                 kind: "libCall",
@@ -4460,9 +4426,9 @@ export function lowerNew(L, expr) {
         }
         // `new Readable({...})` and the other stream classes: the options
         // object parses structurally in the stream spoke.
-        const streamInfo = builtinStreamInfoOf(L, symbol);
+        const streamInfo = builtinStreamInfoOf(lowerer, symbol);
         if (streamInfo)
-            return lowerStreamNew(L, expr, streamInfo);
+            return lowerStreamNew(lowerer, expr, streamInfo);
         // `new URL(input)`: the WHATWG URL class (stdlib/@types provenance —
         // a user's own `class URL` resolves through classBySymbol below).
         // One string argument; invalid input throws a catchable TypeError
@@ -4473,17 +4439,17 @@ export function lowerNew(L, expr) {
         // so bad input throws Node's catchable SyntaxError at construction.
         // String arguments only (Node also accepts a RegExp to copy — that
         // form keeps the fence).
-        if (symbol && symbol.name === "RegExp" && L.isStdlibSymbol(symbol)) {
+        if (symbol && symbol.name === "RegExp" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments ?? [];
             if (args.length > 2) {
-                L.noLowering(`new RegExp with ${args.length} arguments`, expr);
+                lowerer.noLowering(`new RegExp with ${args.length} arguments`, expr);
             }
             const strArg = (a, what) => {
                 if (!a)
                     return { kind: "strLit", value: "", type: STRING, loc };
-                const v = L.lowerExpr(a);
+                const v = lowerer.lowerExpr(a);
                 if (v.type.kind !== "string") {
-                    L.noLowering(`new RegExp with a '${L.fmt(v.type)}' ${what}`, a, "string arguments are the lowered form (a RegExp copy or ToString coercion has no lowering)");
+                    lowerer.noLowering(`new RegExp with a '${lowerer.fmt(v.type)}' ${what}`, a, "string arguments are the lowered form (a RegExp copy or ToString coercion has no lowering)");
                 }
                 return v;
             };
@@ -4491,32 +4457,32 @@ export function lowerNew(L, expr) {
             const flags = strArg(args[1], "flags argument");
             return { kind: "libCall", fn: "regex.new", args: [pattern, flags], type: { kind: "regex" }, loc };
         }
-        if (symbol && symbol.name === "URL" && L.isStdlibSymbol(symbol)) {
+        if (symbol && symbol.name === "URL" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments ?? [];
             if (args.length !== 1) {
-                L.noLowering(`new URL with ${args.length} argument${args.length === 1 ? "" : "s"}`, expr, "one absolute-URL string is the supported form (resolve relative inputs against a base yourself)", symbol);
+                lowerer.noLowering(`new URL with ${args.length} argument${args.length === 1 ? "" : "s"}`, expr, "one absolute-URL string is the supported form (resolve relative inputs against a base yourself)", symbol);
             }
-            const input = L.lowerExprExpecting(args[0], STRING);
+            const input = lowerer.lowerExprExpecting(args[0], STRING);
             return { kind: "libCall", fn: "url.new", args: [input], type: URL_T, loc };
         }
         // `new URLSearchParams(init?)`: the WHATWG list (stdlib provenance —
         // see lowerSearchParamsNew for the lowered init shapes).
-        if (symbol && symbol.name === "URLSearchParams" && L.isStdlibSymbol(symbol)) {
-            return lowerSearchParamsNew(L, expr, loc);
+        if (symbol && symbol.name === "URLSearchParams" && lowerer.isStdlibSymbol(symbol)) {
+            return lowerSearchParamsNew(lowerer, expr, loc);
         }
         // Date's read-only value slice: store the constructor's TimeClip'd
         // epoch milliseconds as the scalar date kind. That is sufficient
         // for every getter and toISOString; identity and setters stay
         // fenced, so copying the scalar cannot create an observable lie.
-        if (symbol && symbol.name === "Date" && L.isStdlibSymbol(symbol)) {
+        if (symbol && symbol.name === "Date" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments ?? [];
             if (args.some(ts.isSpreadElement) || args.length > 1) {
-                L.noLowering(`new Date with ${args.length} arguments`, expr, "new Date(), new Date(milliseconds), and new Date(dateString) are supported; the local-time year/month field constructor has no lowering", symbol);
+                lowerer.noLowering(`new Date with ${args.length} arguments`, expr, "new Date(), new Date(milliseconds), and new Date(dateString) are supported; the local-time year/month field constructor has no lowering", symbol);
             }
             if (args.length === 0) {
                 return { kind: "libCall", fn: "date.newNow", args: [], type: DATE_T, loc };
             }
-            const arg = L.lowerExpr(args[0]);
+            const arg = lowerer.lowerExpr(args[0]);
             if (arg.type.kind === "f64") {
                 return { kind: "libCall", fn: "date.newMs", args: [arg], type: DATE_T, loc };
             }
@@ -4526,7 +4492,7 @@ export function lowerNew(L, expr) {
             if (arg.type.kind === "date") {
                 return arg;
             }
-            L.noLowering(`new Date of '${L.fmt(arg.type)}' values`, args[0], "pass milliseconds, a date string, or another Date value", symbol);
+            lowerer.noLowering(`new Date of '${lowerer.fmt(arg.type)}' values`, args[0], "pass milliseconds, a date string, or another Date value", symbol);
         }
         // `new StringDecoder(encoding?)` (node:string_decoder): the decoder
         // is a two-field record — the CANONICAL encoding name (aliases fold
@@ -4534,15 +4500,15 @@ export function lowerNew(L, expr) {
         // the packed-f64 pending state starting at 0 (nothing buffered).
         // The encoding must be a literal (Node's alias set); omitted means
         // utf8, Node's default.
-        if (symbol && symbol.name === "StringDecoder" && L.isStdlibSymbol(symbol)) {
+        if (symbol && symbol.name === "StringDecoder" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments ?? [];
             if (args.length > 1) {
-                L.noLowering("new StringDecoder with 2 arguments", expr, undefined, symbol);
+                lowerer.noLowering("new StringDecoder with 2 arguments", expr, undefined, symbol);
             }
-            const encName = args.length === 1 ? bufEncoding(L, "new StringDecoder", args[0]) : "utf8";
-            const decT = L.mapTypeOf(L.typeOf(expr));
+            const encName = args.length === 1 ? bufEncoding(lowerer, "new StringDecoder", args[0]) : "utf8";
+            const decT = lowerer.mapTypeOf(lowerer.typeOf(expr));
             if (decT?.kind !== "record")
-                L.badType(expr, L.typeOf(expr));
+                lowerer.badType(expr, lowerer.typeOf(expr));
             return {
                 kind: "recordLit",
                 fields: [
@@ -4556,8 +4522,8 @@ export function lowerNew(L, expr) {
         // Encoder objects likewise never exist: lowerTextCodecCall claims
         // composed calls before the receiver lowers, while the same-scope
         // const store-then-call declaration is erased before reaching here.
-        if (symbol && (symbol.name === "TextDecoder" || symbol.name === "TextEncoder") && L.isStdlibSymbol(symbol)) {
-            L.noLowering(`new ${symbol.name}`, expr, `${symbol.name} values have no representation — a same-scope const store-then-call or the composed form compiles: ` +
+        if (symbol && (symbol.name === "TextDecoder" || symbol.name === "TextEncoder") && lowerer.isStdlibSymbol(symbol)) {
+            lowerer.noLowering(`new ${symbol.name}`, expr, `${symbol.name} values have no representation — a same-scope const store-then-call or the composed form compiles: ` +
                 (symbol.name === "TextDecoder"
                     ? "new TextDecoder().decode(bytes)"
                     : "new TextEncoder().encode(s)"), symbol);
@@ -4567,20 +4533,20 @@ export function lowerNew(L, expr) {
         // representation (stdlib provenance — see lowerBytesNew for the
         // lowered argument shapes; a user's own class with one of the names
         // resolves through classBySymbol below).
-        const bytesNew = L.lowerBytesNew(expr, symbol);
+        const bytesNew = lowerer.lowerBytesNew(expr, symbol);
         if (bytesNew)
             return bytesNew;
-        const info = (symbol ? L.classBySymbol.get(symbol) : undefined) ??
+        const info = (symbol ? lowerer.classBySymbol.get(symbol) : undefined) ??
             // `const C = require('./x'); new C()` over `module.exports =
             // class {…}`: the binding aliases the expression's own symbol —
             // the declaration story, collected on demand.
-            propertyAssignedClassInfoOf(L, symbol) ??
+            propertyAssignedClassInfoOf(lowerer, symbol) ??
             undefined;
         // A rebindable decorated name constructs through its VALUE (the
         // classval-typed path below — newValue through the decoration
         // result's construct thunk), never the declaration directly.
         if (info && info.classDecorators?.valueGlobalId === undefined) {
-            return lowerProgramClassNew(L, expr, info, loc);
+            return lowerProgramClassNew(lowerer, expr, info, loc);
         }
         // `new Map<K, V>()`: the lib Map constructor. The SEEDED forms: an
         // entries ARRAY LITERAL of PAIR LITERALS at the construction site
@@ -4605,46 +4571,46 @@ export function lowerNew(L, expr) {
         // returns its argument for objects and BOXES primitives — the wrapper
         // story with no lowering — so it keeps the constructor fence.
         if (symbol?.name === "Object" &&
-            L.isStdlibSymbol(symbol) &&
+            lowerer.isStdlibSymbol(symbol) &&
             (expr.arguments ?? []).length === 0) {
             return {
                 kind: "recordLit",
                 fields: [],
-                type: { kind: "record", shapeId: L.shapes.intern([]) },
+                type: { kind: "record", shapeId: lowerer.shapes.intern([]) },
                 loc,
             };
         }
-        if (symbol?.name === "Array" && L.isStdlibSymbol(symbol)) {
+        if (symbol?.name === "Array" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments ?? [];
             if (args.some(ts.isSpreadElement)) {
-                L.noLowering("new Array with spread arguments", expr, "write the array literal: [...xs]");
+                lowerer.noLowering("new Array with spread arguments", expr, "write the array literal: [...xs]");
             }
-            if (args.length === 1 && L.mapTypeOf(L.typeOf(args[0]))?.kind === "f64") {
-                L.noLowering("new Array(count)", expr, "the one-number form allocates HOLES (reads answer undefined, which the element type cannot carry) — build and push, or use the elements form: new Array(a, b)");
+            if (args.length === 1 && lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind === "f64") {
+                lowerer.noLowering("new Array(count)", expr, "the one-number form allocates HOLES (reads answer undefined, which the element type cannot carry) — build and push, or use the elements form: new Array(a, b)");
             }
-            let t = L.mapTypeOf(L.typeOf(expr));
+            let t = lowerer.mapTypeOf(lowerer.typeOf(expr));
             // JS's `new Array()` types any[]; the contextual type carries the
             // annotation when one exists (the new Map() stance).
             if (t?.kind !== "array") {
-                const ctx = L.checker.getContextualType(expr);
-                const ctxMapped = ctx ? L.mapTypeOf(ctx) : null;
+                const ctx = lowerer.checker.getContextualType(expr);
+                const ctxMapped = ctx ? lowerer.mapTypeOf(ctx) : null;
                 if (ctxMapped?.kind === "array")
                     t = ctxMapped;
             }
             if (t?.kind !== "array")
-                L.badType(expr, L.typeOf(expr));
-            const elems = args.map((a) => L.lowerExprExpecting(a, t.elem));
+                lowerer.badType(expr, lowerer.typeOf(expr));
+            const elems = args.map((a) => lowerer.lowerExprExpecting(a, t.elem));
             return { kind: "arrayLit", elems, type: t, loc };
         }
-        if (symbol?.name === "Map" && L.isStdlibSymbol(symbol)) {
+        if (symbol?.name === "Map" && lowerer.isStdlibSymbol(symbol)) {
             const seedArg = (expr.arguments?.length ?? 0) === 1 ? expr.arguments[0] : null;
             const isPairLit = (el) => ts.isArrayLiteralExpression(el) && el.elements.length === 2 &&
                 !el.elements.some(ts.isSpreadElement);
             const entriesLit = seedArg && ts.isArrayLiteralExpression(seedArg) && seedArg.elements.every(isPairLit)
                 ? seedArg.elements.filter(isPairLit)
                 : null;
-            let tsType = L.typeOf(expr);
-            let mapped = L.mapTypeOf(tsType);
+            let tsType = lowerer.typeOf(expr);
+            let mapped = lowerer.mapTypeOf(tsType);
             // JavaScript's `new Map()` has no type-argument syntax: the no-arg
             // constructor overload pins Map<any, any> whatever the JSDoc says
             // (`@type` on the declaration types the VARIABLE, not this
@@ -4652,20 +4618,20 @@ export function lowerNew(L, expr) {
             // it when it is a supported map. TS type arguments keep winning:
             // their expression type already maps.
             if (mapped?.kind !== "map") {
-                const ctx = L.checker.getContextualType(expr);
-                const ctxMapped = ctx ? L.mapTypeOf(ctx) : null;
+                const ctx = lowerer.checker.getContextualType(expr);
+                const ctxMapped = ctx ? lowerer.mapTypeOf(ctx) : null;
                 if (ctx && ctxMapped?.kind === "map") {
                     tsType = ctx;
                     mapped = ctxMapped;
                 }
             }
             if (seedArg && !entriesLit && mapped?.kind === "map") {
-                const seeded = lowerMapSeedArrayNew(L, seedArg, mapped);
+                const seeded = lowerMapSeedArrayNew(lowerer, seedArg, mapped);
                 if (seeded)
                     return seeded;
             }
             if ((expr.arguments?.length ?? 0) > 0 && !entriesLit) {
-                L.noLowering("new Map(entries)", expr, "supported seeds: an array literal of [key, value] pair literals, or a " +
+                lowerer.noLowering("new Map(entries)", expr, "supported seeds: an array literal of [key, value] pair literals, or a " +
                     "[K, V][]-typed tuple-array value — construct the Map empty and set() " +
                     "each entry otherwise");
             }
@@ -4673,12 +4639,12 @@ export function lowerNew(L, expr) {
                 if (!entriesLit)
                     return { kind: "mapNew", type: mapped, loc };
                 const seed = entriesLit.map((pair) => ({
-                    key: L.lowerExprExpecting(pair.elements[0], mapped.key),
-                    value: L.lowerExprExpecting(pair.elements[1], mapped.value),
+                    key: lowerer.lowerExprExpecting(pair.elements[0], mapped.key),
+                    value: lowerer.lowerExprExpecting(pair.elements[1], mapped.value),
                 }));
                 return { kind: "mapNew", seed, type: mapped, loc };
             }
-            const targs = L.checker.getTypeArguments(tsType);
+            const targs = lowerer.checker.getTypeArguments(tsType);
             // JAVASCRIPT `new Map()` whose arguments never resolved past
             // Map<any, any> (no annotation, no contextual type, no seed): the
             // WeakMap stance below — the VALUE lowers as an opaque dyn object
@@ -4693,17 +4659,17 @@ export function lowerNew(L, expr) {
                 targs.every((t) => (t.flags & ts.TypeFlags.Any) !== 0)) {
                 return { kind: "dynObjLit", type: DYN, loc };
             }
-            const keyIr = targs[0] ? L.mapTypeOf(targs[0]) : null;
+            const keyIr = targs[0] ? lowerer.mapTypeOf(targs[0]) : null;
             if (targs[0] && (!keyIr || !isSupportedMapKey(keyIr))) {
-                L.unsupported("SC1090", expr, `Map keys of type '${L.checker.typeToString(targs[0])}' ` +
+                lowerer.unsupported("SC1090", expr, `Map keys of type '${lowerer.checker.typeToString(targs[0])}' ` +
                     `(Map keys must be string or number)`);
             }
             if (targs[1]) {
-                L.unsupported("SC1090", expr, `Map values of type '${L.checker.typeToString(targs[1])}' ` +
+                lowerer.unsupported("SC1090", expr, `Map values of type '${lowerer.checker.typeToString(targs[1])}' ` +
                     `(Map values must be number, string, boolean, records, class instances, ` +
                     `arrays, promises, or unions of those — not functions, Maps, 'unknown', or 'any')`);
             }
-            L.badType(expr, tsType);
+            lowerer.badType(expr, tsType);
         }
         // `new Set<T>()`: Map's sibling. The SEEDED form lowers for any
         // T[]-typed argument — literal or variable, T already a legal
@@ -4718,14 +4684,14 @@ export function lowerNew(L, expr) {
         // every reached METHOD use meets its own per-site fence → runtime
         // fence). TypeScript keeps the compile fence.
         if ((symbol?.name === "WeakMap" || symbol?.name === "WeakSet") &&
-            L.isStdlibSymbol(symbol) &&
+            lowerer.isStdlibSymbol(symbol) &&
             isJsSourceFile(expr.getSourceFile()) &&
             (expr.arguments?.length ?? 0) === 0) {
             return { kind: "dynObjLit", type: DYN, loc };
         }
-        if (symbol?.name === "Set" && L.isStdlibSymbol(symbol)) {
-            const tsType = L.typeOf(expr);
-            const mapped = L.mapTypeOf(tsType);
+        if (symbol?.name === "Set" && lowerer.isStdlibSymbol(symbol)) {
+            const tsType = lowerer.typeOf(expr);
+            const mapped = lowerer.mapTypeOf(tsType);
             if (mapped?.kind === "set" && (expr.arguments?.length ?? 0) === 1) {
                 const argNode = expr.arguments[0];
                 // An array LITERAL seed builds element-wise (its contextual type
@@ -4733,14 +4699,14 @@ export function lowerNew(L, expr) {
                 // union — unmappable, so the generic literal path can't type it);
                 // an array-typed VALUE seed lowers as itself.
                 if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-                    const elems = argNode.elements.map((el) => L.lowerExprExpecting(el, mapped.elem));
+                    const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, mapped.elem));
                     const seed = { kind: "arrayLit", elems, type: arrayOf(mapped.elem), loc };
                     return { kind: "setNew", seed, type: mapped, loc };
                 }
                 if (!ts.isSpreadElement(argNode)) {
-                    const argIr = L.mapTypeOf(L.typeOf(argNode));
+                    const argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
                     if (argIr?.kind === "array" && typeEquals(argIr.elem, mapped.elem)) {
-                        let seed = L.lowerExpr(argNode);
+                        let seed = lowerer.lowerExpr(argNode);
                         // A T[]-DECLARED seed whose value is an island handle (a
                         // package's exported array — the binding never held a
                         // static array): the VALIDATED exit copies the engine
@@ -4748,7 +4714,7 @@ export function lowerNew(L, expr) {
                         // lying handle), and the bulk add proceeds on the copy —
                         // construction reads the seed once, so the aliasing
                         // divergence has nothing to observe.
-                        if (seed.type.kind === "jsval" && L.boundaryExitSafe(arrayOf(mapped.elem))) {
+                        if (seed.type.kind === "jsval" && lowerer.boundaryExitSafe(arrayOf(mapped.elem))) {
                             seed = { kind: "jsExit", value: seed, type: arrayOf(mapped.elem), loc: seed.loc };
                         }
                         if (typeEquals(seed.type, arrayOf(mapped.elem))) {
@@ -4770,7 +4736,7 @@ export function lowerNew(L, expr) {
                 ts.isArrayLiteralExpression(expr.arguments[0]) &&
                 !expr.arguments[0].elements.some(ts.isSpreadElement)) {
                 const lit = expr.arguments[0];
-                const elems = lit.elements.map((el) => L.lowerExpr(el));
+                const elems = lit.elements.map((el) => lowerer.lowerExpr(el));
                 const first = elems[0];
                 if (first !== undefined &&
                     (first.type.kind === "string" || first.type.kind === "f64") &&
@@ -4781,35 +4747,35 @@ export function lowerNew(L, expr) {
                 }
             }
             if ((expr.arguments?.length ?? 0) > 0) {
-                L.noLowering("new Set(values)", expr, "construct the Set empty and add() each value — only an array of " +
+                lowerer.noLowering("new Set(values)", expr, "construct the Set empty and add() each value — only an array of " +
                     "already-legal elements (string or number) seeds a Set");
             }
             if (mapped?.kind === "set")
                 return { kind: "setNew", type: mapped, loc };
-            const targs = L.checker.getTypeArguments(tsType);
+            const targs = lowerer.checker.getTypeArguments(tsType);
             if (targs[0]) {
-                L.unsupported("SC1090", expr, `Set elements of type '${L.checker.typeToString(targs[0])}' ` +
+                lowerer.unsupported("SC1090", expr, `Set elements of type '${lowerer.checker.typeToString(targs[0])}' ` +
                     `(Set elements must be string or number — Map's key kinds — or a server handle, which stores under reference identity)`);
             }
-            L.badType(expr, tsType);
+            lowerer.badType(expr, tsType);
         }
         // `new AsyncLocalStorage()` (node:async_hooks): a fresh store id —
-        // an f64 handle (types.ts), the Channel story. Construction options
+        // an f64 handle (type-mapper.ts), the Channel story. Construction options
         // ({ defaultValue, name }) have no lowering yet.
-        if (symbol?.name === "AsyncLocalStorage" && L.isStdlibSymbol(symbol)) {
+        if (symbol?.name === "AsyncLocalStorage" && lowerer.isStdlibSymbol(symbol)) {
             if ((expr.arguments?.length ?? 0) > 0) {
-                L.noLowering("new AsyncLocalStorage(options)", expr, "the zero-argument constructor is the supported form (defaultValue/name options have no lowering yet)");
+                lowerer.noLowering("new AsyncLocalStorage(options)", expr, "the zero-argument constructor is the supported form (defaultValue/name options have no lowering yet)");
             }
             return { kind: "libCall", fn: "als.new", args: [], type: F64, loc };
         }
         // `new Promise<T>((resolve) => ...)`: the ambient Promise constructor.
-        if (symbol?.name === "Promise" && L.isStdlibSymbol(symbol)) {
-            const type = L.irTypeOf(expr);
+        if (symbol?.name === "Promise" && lowerer.isStdlibSymbol(symbol)) {
+            const type = lowerer.irTypeOf(expr);
             if (type.kind !== "promise")
-                L.badType(expr, L.typeOf(expr));
+                lowerer.badType(expr, lowerer.typeOf(expr));
             const args = expr.arguments ?? [];
             if (args.length !== 1) {
-                L.unsupported("SC1090", expr, "Promise construction without an executor");
+                lowerer.unsupported("SC1090", expr, "Promise construction without an executor");
             }
             // `new Promise(setImmediate)` (the Node-suite early-exit shape):
             // the executor IS the stdlib setImmediate, so resolve rides the
@@ -4818,9 +4784,9 @@ export function lowerNew(L, expr) {
             {
                 const a0 = args[0];
                 if (ts.isIdentifier(a0) && a0.text === "setImmediate") {
-                    const sym = L.checker.getSymbolAtLocation(a0);
-                    const decls = sym ? L.checker.declarationsOf(sym) : [];
-                    if (decls.length > 0 && decls.every((d) => L.isStdlibFile(d.getSourceFile()))) {
+                    const sym = lowerer.checker.getSymbolAtLocation(a0);
+                    const decls = sym ? lowerer.checker.declarationsOf(sym) : [];
+                    if (decls.length > 0 && decls.every((d) => lowerer.isStdlibFile(d.getSourceFile()))) {
                         // The settled value is the undefined dyn value — the result
                         // is promise<dyn> whatever T the checker inferred for the
                         // unusual executor (Promise<unknown> in the suite's shape).
@@ -4841,9 +4807,9 @@ export function lowerNew(L, expr) {
             // catch-side instanceof and the uncaught printer working). First
             // settle wins, exactly JS: reject-after-resolve and double-reject
             // are no-ops, and an executor throw after any settle is swallowed.
-            const executor = L.lowerExpr(args[0]);
+            const executor = lowerer.lowerExpr(args[0]);
             if (executor.type.kind !== "func")
-                L.badType(args[0], L.typeOf(args[0]));
+                lowerer.badType(args[0], lowerer.typeOf(args[0]));
             if (executor.type.params.length > 1) {
                 const rj = executor.type.params[1];
                 if (executor.type.params.length > 2 ||
@@ -4854,7 +4820,7 @@ export function lowerNew(L, expr) {
                     rj.params[0].className !== "%Error") {
                     // A non-contextually-typed executor VALUE whose second param
                     // isn't the pinned (reason: Error) => void shape.
-                    L.unsupported("SC1090", args[0], "Promise executors whose reject parameter is not '(reason: Error) => void'");
+                    lowerer.unsupported("SC1090", args[0], "Promise executors whose reject parameter is not '(reason: Error) => void'");
                 }
             }
             return { kind: "newPromise", executor, type, loc };
@@ -4865,7 +4831,7 @@ export function lowerNew(L, expr) {
         // TextEncoder, ...) typechecks and reports SC2020 here. The named
         // families carry pointed hints: each states WHY no honest static
         // lowering exists (or what to use instead).
-        if (L.isStdlibSymbol(symbol ?? undefined)) {
+        if (lowerer.isStdlibSymbol(symbol ?? undefined)) {
             // The deprecated `new Buffer(string, encoding?)` ctor's string arm
             // with a NON-STRING first argument and a string second: Node
             // throws ERR_INVALID_ARG_TYPE synchronously (and DEP0005 never
@@ -4875,16 +4841,16 @@ export function lowerNew(L, expr) {
             if (expr.expression.text === "Buffer" &&
                 expr.arguments?.length === 2 &&
                 !expr.arguments.some(ts.isSpreadElement) &&
-                L.mapTypeOf(L.typeOf(expr.arguments[0]))?.kind !== "string" &&
-                L.mapTypeOf(L.typeOf(expr.arguments[1]))?.kind === "string") {
-                const first = L.lowerExpr(expr.arguments[0]);
-                if (first.kind === "unitLit" || first.type.kind === "dyn" || L.dynConvertible(first.type)) {
+                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[0]))?.kind !== "string" &&
+                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]))?.kind === "string") {
+                const first = lowerer.lowerExpr(expr.arguments[0]);
+                if (first.kind === "unitLit" || first.type.kind === "dyn" || lowerer.dynConvertible(first.type)) {
                     const got = first.type.kind === "dyn" ? first : { kind: "dynFrom", value: first, type: DYN, loc };
                     // The encoding argument still evaluates in Node before the
                     // throw only via the ctor body's later reads — it does NOT
                     // observe it before throwing, so dropping it is exact for
                     // effect-free operands; effectful ones keep the fence.
-                    const enc = L.lowerExpr(expr.arguments[1]);
+                    const enc = lowerer.lowerExpr(expr.arguments[1]);
                     if (enc.kind === "strLit" || pureReemittable(enc)) {
                         return { kind: "libCall", fn: "buffer.newStringFail", args: [got], type: bytesOf("u8"), loc };
                     }
@@ -4904,7 +4870,7 @@ export function lowerNew(L, expr) {
                 Proxy: "property-access metaprogramming has no static lowering (every property read must resolve at compile time)",
                 Function: "runtime code generation cannot be compiled ahead of time (the eval stance) — write the function",
             };
-            L.noLowering(`new ${expr.expression.text}`, expr, ctorHints[expr.expression.text], symbol);
+            lowerer.noLowering(`new ${expr.expression.text}`, expr, ctorHints[expr.expression.text], symbol);
         }
     }
     // `new crypto.X509Certificate(data)` — the Dirent-style data record:
@@ -4923,37 +4889,37 @@ export function lowerNew(L, expr) {
         const callee = expr.expression;
         const isX509 = (ts.isPropertyAccessExpression(callee) &&
             callee.name.text === "X509Certificate" &&
-            L.builtinNamespaceModuleOf(callee.expression) === "crypto") ||
+            lowerer.builtinNamespaceModuleOf(callee.expression) === "crypto") ||
             (ts.isIdentifier(callee) &&
                 (() => {
-                    const bi = L.builtinImportOf(callee);
+                    const bi = lowerer.builtinImportOf(callee);
                     return bi?.module === "crypto" && bi.member === "X509Certificate";
                 })());
         if (isX509) {
             const args = expr.arguments ?? [];
             if (args.length !== 1) {
-                L.noLowering("X509Certificate with this argument shape", expr, "the supported form is new X509Certificate(readFileSync(path))");
+                lowerer.noLowering("X509Certificate with this argument shape", expr, "the supported form is new X509Certificate(readFileSync(path))");
             }
-            const data = L.lowerExpr(args[0]);
+            const data = lowerer.lowerExpr(args[0]);
             const isBytes = data.type.kind === "bytes" && data.type.elem === "u8";
             if (!isBytes && data.type.kind !== "string") {
-                L.noLowering(`X509Certificate over '${L.fmt(data.type)}' data`, args[0], "pass the certificate Buffer or PEM string (an fs.readFileSync result)");
+                lowerer.noLowering(`X509Certificate over '${lowerer.fmt(data.type)}' data`, args[0], "pass the certificate Buffer or PEM string (an fs.readFileSync result)");
             }
-            const t = L.mapTypeOf(L.typeOf(expr));
+            const t = lowerer.mapTypeOf(lowerer.typeOf(expr));
             if (t?.kind !== "record")
-                L.badType(expr, L.typeOf(expr));
+                lowerer.badType(expr, lowerer.typeOf(expr));
             const key = `x509.record:${isBytes ? "bytes" : "str"}`;
-            let helper = L.widthHelpers.get(key);
+            let helper = lowerer.widthHelpers.get(key);
             if (!helper) {
-                helper = `%x509.record.${L.widthHelpers.size}`;
-                L.widthHelpers.set(key, helper);
+                helper = `%x509.record.${lowerer.widthHelpers.size}`;
+                lowerer.widthHelpers.set(key, helper);
                 const dataT = data.type;
                 const dRef = { kind: "varRef", localId: "d.0", type: dataT, loc };
                 const field = (name, fn) => ({
                     name,
                     value: { kind: "libCall", fn, args: [dRef], type: STRING, loc },
                 });
-                L.liftedFns.push({
+                lowerer.liftedFns.push({
                     name: helper,
                     params: [{ localId: "d.0", name: "d", type: dataT }],
                     returnType: t,
@@ -4989,47 +4955,47 @@ export function lowerNew(L, expr) {
     // callee (unannotated heterogeneous registries) keeps a pointed
     // fence — annotate the slot with the common constructor type.
     {
-        const calleeT = L.mapTypeOf(L.typeOf(expr.expression));
+        const calleeT = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
         if (calleeT?.kind === "classval") {
-            let info = L.classes.get(calleeT.className);
+            let info = lowerer.classes.get(calleeT.className);
             if (!info && ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.name)) {
                 // A property-assigned class expression not collected yet (this
                 // body lowers ahead of the assignment statement — hoisted
                 // functions): collect it on demand and retry, keeping the
                 // dynamic newValue dispatch below (the runtime field value
                 // decides, exactly Node under reassignment-through-aliases).
-                propertyAssignedClassInfoOf(L, L.checker.getSymbolAtLocation(expr.expression.name));
-                info = L.classes.get(calleeT.className);
+                propertyAssignedClassInfoOf(lowerer, lowerer.checker.getSymbolAtLocation(expr.expression.name));
+                info = lowerer.classes.get(calleeT.className);
             }
             if (!info) {
                 // The TYPE world names a class the lowering never registered —
                 // a fenced class expression, an abstract/deferred declaration:
                 // flush its own diagnostics (they tell the real story) and
                 // poison this construction site, never an ICE.
-                L.flushDeferredClass(calleeT.className);
-                L.unsupported("SC1090", expr, "constructing through a class value whose class has no lowering (the class declaration itself was rejected — see its own diagnostic)");
+                lowerer.flushDeferredClass(calleeT.className);
+                lowerer.unsupported("SC1090", expr, "constructing through a class value whose class has no lowering (the class declaration itself was rejected — see its own diagnostic)");
             }
             // A classval of a generic FAMILY (`new () => Box<any>` slots): no
             // single constructor ABI exists to complete against. No producer
             // can fill such a slot (family values and widenings both fence),
             // so the construction site is the honest place to name it.
             if (info.generic) {
-                L.unsupported("SC1090", expr, "constructing through a class value of an uninstantiated generic type (annotate the slot with a concrete instantiation — e.g. 'new (v: number) => Box<number>')");
+                lowerer.unsupported("SC1090", expr, "constructing through a class value of an uninstantiated generic type (annotate the slot with a concrete instantiation — e.g. 'new (v: number) => Box<number>')");
             }
-            const callee = L.lowerExpr(expr.expression);
+            const callee = lowerer.lowerExpr(expr.expression);
             if (callee.type.kind !== "classval")
-                L.badType(expr.expression, L.typeOf(expr.expression));
-            L.noteEdge(`%${info.def.name}.constructor`);
+                lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
+            lowerer.noteEdge(`%${info.def.name}.constructor`);
             // Every constructor a value in this slot can dispatch to is a
             // descendant's — mark them reachable like a virtual edge.
             const below = (c) => {
                 for (const s of c.subclasses) {
-                    L.noteEdge(`%${s.def.name}.constructor`);
+                    lowerer.noteEdge(`%${s.def.name}.constructor`);
                     below(s);
                 }
             };
             below(info);
-            const args = L.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
+            const args = lowerer.completeArgs(expr.arguments ?? [], info.ctorParams, loc, expr);
             return {
                 kind: "newValue",
                 callee,
@@ -5039,9 +5005,9 @@ export function lowerNew(L, expr) {
             };
         }
         if (calleeT?.kind === "union") {
-            const def = L.unions.get(calleeT.unionId);
+            const def = lowerer.unions.get(calleeT.unionId);
             if (def?.arms.some((a) => a.kind === "classval")) {
-                L.unsupported("SC1090", expr, "constructing through a union of class values (annotate the slot with the common constructor type — e.g. `new () => Base` — or narrow first)");
+                lowerer.unsupported("SC1090", expr, "constructing through a union of class values (annotate the slot with the common constructor type — e.g. `new () => Base` — or narrow first)");
             }
         }
     }
@@ -5058,45 +5024,45 @@ export function lowerNew(L, expr) {
                 ? expr.expression.name
                 : null;
         if (ctorName !== null) {
-            const raw = L.checker.getSymbolAtLocation(ctorName);
-            const sym = raw && raw.flags & ts.SymbolFlags.Alias ? L.checker.getAliasedSymbol(raw) : raw;
-            const hint = sym && L.isStdlibSymbol(sym) ? own(STDLIB_CTOR_HINTS, sym.name) : undefined;
+            const raw = lowerer.checker.getSymbolAtLocation(ctorName);
+            const sym = raw && raw.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(raw) : raw;
+            const hint = sym && lowerer.isStdlibSymbol(sym) ? own(STDLIB_CTOR_HINTS, sym.name) : undefined;
             if (hint !== undefined) {
-                L.unsupported("SC1090", expr, hint);
+                lowerer.unsupported("SC1090", expr, hint);
             }
         }
     }
-    L.unsupported("SC1090", expr, "constructing values other than classes declared in the program");
+    lowerer.unsupported("SC1090", expr, "constructing values other than classes declared in the program");
 }
 /** A getter/setter invocation over an accessor target's receiver — the
    * same whole-program devirtualization as method calls: a virtualCall
    * when some strict subclass of the receiver's static class overrides
    * this HALF of the accessor (get and set devirtualize independently),
    * a direct call of the nearest declaration otherwise. */
-export function accessorCall(L, className, member, obj, extraArgs, ret, loc) {
-    const info = L.classes.get(className);
+export function accessorCall(lowerer, className, member, obj, extraArgs, ret, loc) {
+    const info = lowerer.classes.get(className);
     if (!info)
-        throw new Error(`lowerer bug: accessor call on unknown class ${className}`);
-    const found = L.findMethodOn(info, member);
+        throw new InternalCompilerError(`lowerer bug: accessor call on unknown class ${className}`);
+    const found = lowerer.findMethodOn(info, member);
     if (!found)
-        throw new Error(`lowerer bug: no ${member} on ${className}`);
+        throw new InternalCompilerError(`lowerer bug: no ${member} on ${className}`);
     // The abstract direct-call fence, accessor form (see
     // lowerObjectMethodCall): an abstract accessor with no concrete
     // override below has no implementation for a direct call to target.
-    if (found.sig.abstract === true && !L.overrideBelow(info, member)) {
-        L.pushDiag(unsupportedDiag("SC1090", loc, `${member.startsWith("get:") ? "reads" : "writes"} of the abstract accessor '${member.slice(4)}' with no concrete implementation below the receiver's static class`));
+    if (found.sig.abstract === true && !lowerer.overrideBelow(info, member)) {
+        lowerer.pushDiag(unsupportedDiag("SC1090", loc, `${member.startsWith("get:") ? "reads" : "writes"} of the abstract accessor '${member.slice(4)}' with no concrete implementation below the receiver's static class`));
         throw new PoisonError();
     }
-    if (L.overrideBelow(info, member))
-        L.noteVirtualEdge(info, member);
+    if (lowerer.overrideBelow(info, member))
+        lowerer.noteVirtualEdge(info, member);
     else
-        L.noteEdge(`%${found.declarer.def.name}.${member}`);
-    if (L.overrideBelow(info, member)) {
+        lowerer.noteEdge(`%${found.declarer.def.name}.${member}`);
+    if (lowerer.overrideBelow(info, member)) {
         return {
             kind: "virtualCall",
             className: info.def.name,
             method: member,
-            args: [L.upcastTo(obj, info.def.name), ...extraArgs],
+            args: [lowerer.upcastTo(obj, info.def.name), ...extraArgs],
             type: ret,
             loc,
         };
@@ -5104,7 +5070,7 @@ export function accessorCall(L, className, member, obj, extraArgs, ret, loc) {
     return {
         kind: "call",
         callee: `%${found.declarer.def.name}.${member}`,
-        args: [L.upcastTo(obj, found.declarer.def.name), ...extraArgs],
+        args: [lowerer.upcastTo(obj, found.declarer.def.name), ...extraArgs],
         type: ret,
         loc,
     };
@@ -5113,7 +5079,7 @@ export function accessorCall(L, className, member, obj, extraArgs, ret, loc) {
  * `time = async <T>(...) => {...}` or `= function g<T>(...) {...}`
  * (parens stripped): bindingGenericFnNodeOf's shape rule, member form.
  * Null when the field isn't that shape. */
-export function genericFieldFnNodeOf(member) {
+function genericFieldFnNodeOf(member) {
     if (member.initializer === undefined)
         return null;
     let init = member.initializer;