@scriptc/compiler 0.0.35 → 0.1.1

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

@@ -6,10 +6,11 @@ import * as ts from "../ts7/adapter.js";
 import { dirname as dirnamePath, resolve as resolvePath } from "node:path";
 import { NpmGraphBuilder, packageNameOfPath, probeNodeImportRefusal, probeNodeRequireRefusal } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
-import { isJsSourceFileName, isRelativeSpecifier } from "../shared.js";
+import { isJsSourceFileName } from "../tsc-codes.js";
+import { isRelativeSpecifier } from "../workspace-registry.js";
 import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, resolveImport, resolveNpmImport } from "../program.js";
 import { invalidJsonModuleDiag, npmEmbedFailedDiag, requiresDynamicImportDiag } from "../../diagnostics/diagnostic.js";
-import { BOOL, DYN, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canConvertToDyn, isUnitType } from "../../ir/nodes.js";
+import { BOOL, DYN, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canConvertToDyn, isUnitType } from "../../ir/ir.js";
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, uncheckedOverloadHandleCall } from "./lowerer.js";
 import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, isPromisifyCall, textCodecBindingDecl } from "./lower-builtins.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf } from "./lower-calls.js";
@@ -18,7 +19,7 @@ import { streamClassAliasDecl } from "./lower-stream.js";
 import { stdlibGlobalAliasDecl } from "./surfaces.js";
 import { collectNamespaceStmt, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
-import { isUnitOnlyTsType, unitOnlyUnion } from "../types.js";
+import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
 import { decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow } from "./lower-classes.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 /** Splits each file into function/class declarations and the top-level
@@ -26,8 +27,8 @@ import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
    * postorder, entry last), computed by preflight. Single-file programs
    * (tests, coverage on broken files) may arrive with an empty order — fall
    * back to the entry alone. */
-export function splitFiles(L) {
-    const files = L.moduleOrder.length > 0 ? L.moduleOrder : [L.entry];
+export function splitFiles(lowerer) {
+    const files = lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry];
     return files.map((sf) => {
         const fp = { sf, fnDecls: [], classDecls: [], topStmts: [] };
         for (const stmt of sf.statements) {
@@ -40,7 +41,7 @@ export function splitFiles(L) {
             // classes hoist under namespace-qualified names, statements join
             // the init body in source order) — lower-namespaces.ts.
             else if (ts.isModuleDeclaration(stmt))
-                collectNamespaceStmt(L, stmt, fp);
+                collectNamespaceStmt(lowerer, stmt, fp);
             else if (ts.isInterfaceDeclaration(stmt) ||
                 ts.isTypeAliasDeclaration(stmt) ||
                 ts.isImportDeclaration(stmt) ||
@@ -61,7 +62,7 @@ export function splitFiles(L) {
    * that is not JSON and not CommonJS-flavored (a CJS namespace is built
    * from module.exports through Node's lexer — a different surface with no
    * static story here). Null for everything else. */
-export function dynamicImportProgramTargetOf(program, sf, spec) {
+function dynamicImportProgramTargetOf(program, sf, spec) {
     if (!isRelativeSpecifier(spec) && !spec.startsWith("/"))
         return null;
     const dep = resolveImport(program, sf, spec);
@@ -164,40 +165,40 @@ export function appendDynamicImportModules(program, order, onCycle) {
    * cross-module references fall out for free. Runs in both passes —
    * signatures are cheap and calls resolve against them; only BODY lowering
    * is reachability-gated. */
-export function collectProgram(L, parts) {
-    L.collecting = true;
+export function collectProgram(lowerer, parts) {
+    lowerer.collecting = true;
     try {
         for (const fp of parts)
             for (const decl of fp.classDecls)
-                L.collectClassShape(decl);
+                lowerer.collectClassShape(decl);
         for (const fp of parts)
             for (const decl of fp.fnDecls)
-                L.collectSignature(decl);
+                lowerer.collectSignature(decl);
     }
     finally {
-        L.collecting = false;
+        lowerer.collecting = false;
     }
     // Globals are top-level (always reachable), so their collection reports
     // eagerly — including deferred-class flushes their types trigger. The
     // coverage remainder still needs the registrations but the emit pass
     // already reported the diagnostics; discard the duplicates.
-    if (L.remainder) {
-        L.diagSink = [];
+    if (lowerer.remainder) {
+        lowerer.diagSink = [];
         try {
             for (const fp of parts)
-                L.collectGlobals(fp.sf, fp.topStmts);
-            L.collectNpmImports(parts);
-            L.collectJsonImports(parts);
+                lowerer.collectGlobals(fp.sf, fp.topStmts);
+            lowerer.collectNpmImports(parts);
+            lowerer.collectJsonImports(parts);
         }
         finally {
-            L.diagSink = null;
+            lowerer.diagSink = null;
         }
     }
     else {
         for (const fp of parts)
-            L.collectGlobals(fp.sf, fp.topStmts);
-        L.collectNpmImports(parts);
-        L.collectJsonImports(parts);
+            lowerer.collectGlobals(fp.sf, fp.topStmts);
+        lowerer.collectNpmImports(parts);
+        lowerer.collectJsonImports(parts);
     }
 }
 /** The npm-import chokepoint, run once per pass during collection (so
@@ -213,8 +214,8 @@ export function collectProgram(L, parts) {
    * builds here too; its failures are ordinary diagnostics at the import
    * site. Type-only imports are free either way: the .d.ts is a type
    * surface, not code. */
-export function collectNpmImports(L, parts) {
-    const builder = L.dynamic ? new NpmGraphBuilder() : null;
+export function collectNpmImports(lowerer, parts) {
+    const builder = lowerer.dynamic ? new NpmGraphBuilder() : null;
     for (const fp of parts) {
         for (const stmt of fp.sf.statements) {
             // NAMED re-exports from npm packages (`export { isUrl } from
@@ -253,7 +254,7 @@ export function collectNpmImports(L, parts) {
             // selects its package), the declaration mapping promises no npm or
             // island runtime implementation; the preflight/import-use SC1010
             // fences are the whole story.
-            if (L.externalTypes.has(spec))
+            if (lowerer.externalTypes.has(spec))
                 continue;
             const npm = resolveNpmImport(fp.sf.fileName, spec);
             // --npm-static: an opted-in package that made it through preflight
@@ -264,7 +265,7 @@ export function collectNpmImports(L, parts) {
             if (npm !== null &&
                 isNpmStaticPackage(npm.packageName) &&
                 isJsSourceFileName(npm.typesFile) &&
-                L.program.getSourceFile(npm.typesFile) !== undefined) {
+                lowerer.program.getSourceFile(npm.typesFile) !== undefined) {
                 continue;
             }
             // A RELATIVE specifier resolving INTO node_modules (the e2e driver
@@ -293,7 +294,7 @@ export function collectNpmImports(L, parts) {
             if (npm !== null && probeNodeImportRefusal(fp.sf.fileName, spec) !== null)
                 continue;
             if (!builder) {
-                L.pushDiag(requiresDynamicImportDiag(npm?.packageName ?? relPkg, locOf(stmt)));
+                lowerer.pushDiag(requiresDynamicImportDiag(npm?.packageName ?? relPkg, locOf(stmt)));
                 continue;
             }
             const before = builder.errors.length;
@@ -301,13 +302,13 @@ export function collectNpmImports(L, parts) {
                 ? (builder.addImport(fp.sf.fileName, spec), builder.entryOf(fp.sf.fileName, spec))
                 : builder.addFileImport(fp.sf.fileName, spec);
             for (const err of builder.errors.slice(before)) {
-                L.pushDiag(npmEmbedFailedDiag(err.message, locOf(stmt)));
+                lowerer.pushDiag(npmEmbedFailedDiag(err.message, locOf(stmt)));
             }
             if (entryKey === null)
                 continue; // resolution failed — reported above
             const loc = locOf(stmt);
-            const byStmt = L.npmInitActions.get(fp.sf) ?? new Map();
-            L.npmInitActions.set(fp.sf, byStmt);
+            const byStmt = lowerer.npmInitActions.get(fp.sf) ?? new Map();
+            lowerer.npmInitActions.set(fp.sf, byStmt);
             const actions = byStmt.get(stmt) ?? [];
             byStmt.set(stmt, actions);
             const importExpr = (exportName) => ({
@@ -326,22 +327,22 @@ export function collectNpmImports(L, parts) {
                 loc,
             });
             const bind = (nameNode, exportName) => {
-                let symbol = L.checker.getSymbolAtLocation(nameNode);
+                let symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                 if (symbol && symbol.flags & ts.SymbolFlags.Alias) {
-                    symbol = L.checker.getAliasedSymbol(symbol);
+                    symbol = lowerer.checker.getAliasedSymbol(symbol);
                 }
                 if (!symbol)
                     return;
-                let g = L.globalsBySymbol.get(symbol);
+                let g = lowerer.globalsBySymbol.get(symbol);
                 if (!g) {
                     g = {
-                        id: `%g.npm.${L.globalsList.length}`,
+                        id: `%g.npm.${lowerer.globalsList.length}`,
                         name: nameNode.text,
                         type: JSVAL,
                         mutable: false,
                     };
-                    L.globalsBySymbol.set(symbol, g);
-                    L.globalsList.push(g);
+                    lowerer.globalsBySymbol.set(symbol, g);
+                    lowerer.globalsList.push(g);
                 }
                 actions.push({ kind: "assign", localId: g.id, value: importExpr(exportName), loc });
             };
@@ -376,17 +377,17 @@ export function collectNpmImports(L, parts) {
     }
     if (builder) {
         for (const fp of parts)
-            collectDynamicImports(L, builder, fp.sf);
+            collectDynamicImports(lowerer, builder, fp.sf);
         for (const fp of parts)
-            collectCreateRequires(L, builder, fp.sf);
+            collectCreateRequires(lowerer, builder, fp.sf);
         const graph = builder.finish();
         if (graph.modules.length > 0) {
-            L.npmEmbedded = { modules: graph.modules, edges: graph.edges };
+            lowerer.npmEmbedded = { modules: graph.modules, edges: graph.edges };
         }
         if (graph.builtins.length > 0)
-            L.npmBuiltins = graph.builtins;
+            lowerer.npmBuiltins = graph.builtins;
         if (graph.lazyTraps.length > 0)
-            L.npmLazyTraps = graph.lazyTraps;
+            lowerer.npmLazyTraps = graph.lazyTraps;
     }
 }
 /** The dynamic-import half of the npm chokepoint (--dynamic only): every
@@ -400,7 +401,7 @@ export function collectNpmImports(L, parts) {
    * specifiers are skipped — the lowering owns that fence (the module
    * graph is a build-time artifact; there is nothing to embed for a
    * runtime-computed name). */
-function collectDynamicImports(L, builder, sf) {
+function collectDynamicImports(lowerer, builder, sf) {
     const visit = (node) => {
         if (ts.isCallExpression(node) &&
             node.expression.kind === ts.SyntaxKind.ImportKeyword &&
@@ -408,28 +409,28 @@ function collectDynamicImports(L, builder, sf) {
             node.arguments[0] !== undefined &&
             ts.isStringLiteralLike(node.arguments[0])) {
             const spec = node.arguments[0].text;
-            if (L.externalTypes.has(spec)) {
+            if (lowerer.externalTypes.has(spec)) {
                 ts.forEachChild(node, visit);
                 return;
             }
             const mapKey = `${sf.fileName}\u0000${spec}`;
-            if (!L.dynImports.has(mapKey)) {
+            if (!lowerer.dynImports.has(mapKey)) {
                 // The program's OWN modules first, by the checker's resolution
                 // (tsc already resolved "./helper.js" to helper.ts): a compiled
                 // module has no runtime namespace object — the per-site fence
                 // says so. Only non-declaration source files count; a sibling
                 // .d.mts typing shipped JS is the EMBED case, not this one.
-                const modSym = L.checker.getSymbolAtLocation(node.arguments[0]);
-                const ownModule = modSym !== undefined && L.checker.declarationsOf(modSym).some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
+                const modSym = lowerer.checker.getSymbolAtLocation(node.arguments[0]);
+                const ownModule = modSym !== undefined && lowerer.checker.declarationsOf(modSym).some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
                 const res = ownModule
                     ? { kind: "program-module" }
                     : builder.addDynamicImport(sf.fileName, spec);
-                L.dynImports.set(mapKey, res);
+                lowerer.dynImports.set(mapKey, res);
                 if (res.kind === "unsupported-builtin") {
-                    L.pushDiag(npmEmbedFailedDiag(`'${spec}' is a Node builtin the island does not provide a shim for`, locOf(node)));
+                    lowerer.pushDiag(npmEmbedFailedDiag(`'${spec}' is a Node builtin the island does not provide a shim for`, locOf(node)));
                 }
                 else if (res.kind === "unresolved") {
-                    L.pushDiag(npmEmbedFailedDiag(res.message, locOf(node)));
+                    lowerer.pushDiag(npmEmbedFailedDiag(res.message, locOf(node)));
                 }
             }
         }
@@ -446,10 +447,10 @@ function collectDynamicImports(L, builder, sf) {
    * are the lowering's own arms — only resolvable installed packages
    * register here; resolution failures are diagnostics at the call
    * expression, exactly like static npm imports at their statements. */
-function collectCreateRequires(L, builder, sf) {
+function collectCreateRequires(lowerer, builder, sf) {
     const visit = (node) => {
         if (ts.isCallExpression(node)) {
-            const cr = createRequireSpecOf(L, node);
+            const cr = createRequireSpecOf(lowerer, node);
             const spec = cr?.spec ?? null;
             if (cr !== null &&
                 spec !== null &&
@@ -462,13 +463,13 @@ function collectCreateRequires(L, builder, sf) {
                     ? spec.split("/").slice(0, 2).join("/")
                     : spec.split("/")[0];
                 const mapKey = `${cr.baseFile.fileName}\u0000${spec}`;
-                if (!L.createRequireImports.has(mapKey) && !isNpmStaticPackage(pkgName)) {
+                if (!lowerer.createRequireImports.has(mapKey) && !isNpmStaticPackage(pkgName)) {
                     const before = builder.errors.length;
                     const entryKey = builder.addRequire(cr.baseFile.fileName, spec);
                     for (const err of builder.errors.slice(before)) {
-                        L.pushDiag(npmEmbedFailedDiag(err.message, locOf(node)));
+                        lowerer.pushDiag(npmEmbedFailedDiag(err.message, locOf(node)));
                     }
-                    L.createRequireImports.set(mapKey, entryKey === null
+                    lowerer.createRequireImports.set(mapKey, entryKey === null
                         ? ""
                         : { entryKey, format: builder.moduleFormatOf(entryKey) ?? "cjs" });
                 }
@@ -490,7 +491,7 @@ function collectCreateRequires(L, builder, sf) {
    * arrays, ...) report the standard unsupported-type diagnostic at the
    * import site. Preflight already fenced named/namespace JSON imports
    * and kept .json files out of the module order. */
-export function collectJsonImports(L, parts) {
+export function collectJsonImports(lowerer, parts) {
     for (const fp of parts) {
         for (const stmt of fp.sf.statements) {
             if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
@@ -498,18 +499,18 @@ export function collectJsonImports(L, parts) {
             const clause = stmt.importClause;
             if (!clause?.name || clause.phaseModifier === ts.SyntaxKind.TypeKeyword)
                 continue;
-            const nameSym = L.checker.getSymbolAtLocation(clause.name);
+            const nameSym = lowerer.checker.getSymbolAtLocation(clause.name);
             if (!nameSym || !(nameSym.flags & ts.SymbolFlags.Alias))
                 continue;
-            const target = L.checker.getAliasedSymbol(nameSym);
-            const jsonSf = L.checker.declarationsOf(target)[0]?.getSourceFile();
+            const target = lowerer.checker.getAliasedSymbol(nameSym);
+            const jsonSf = lowerer.checker.declarationsOf(target)[0]?.getSourceFile();
             if (!jsonSf || !jsonSf.fileName.endsWith(".json"))
                 continue;
             try {
-                const tsType = L.typeOf(clause.name);
-                const mapped = L.mapTypeOf(tsType);
-                if (!mapped || !L.comptimeBakeable(mapped)) {
-                    L.badType(clause.name, tsType);
+                const tsType = lowerer.typeOf(clause.name);
+                const mapped = lowerer.mapTypeOf(tsType);
+                if (!mapped || !lowerer.comptimeBakeable(mapped)) {
+                    lowerer.badType(clause.name, tsType);
                 }
                 // tsgo tolerates JSON shapes strict JSON.parse rejects (a leading
                 // `//` comment — importAttributes11), so no SC0001 guarantees a
@@ -520,23 +521,23 @@ export function collectJsonImports(L, parts) {
                     parsed = JSON.parse(jsonSf.text);
                 }
                 catch (e) {
-                    L.pushDiag(invalidJsonModuleDiag(jsonSf.fileName, e instanceof Error ? e.message : String(e), locOf(stmt)));
+                    lowerer.pushDiag(invalidJsonModuleDiag(jsonSf.fileName, e instanceof Error ? e.message : String(e), locOf(stmt)));
                     throw new PoisonError();
                 }
-                const value = L.comptimeValueToIr(parsed, mapped, "$", clause.name);
-                let g = L.globalsBySymbol.get(target);
+                const value = lowerer.comptimeValueToIr(parsed, mapped, "$", clause.name);
+                let g = lowerer.globalsBySymbol.get(target);
                 if (!g) {
                     g = {
-                        id: `%g.json.${L.globalsList.length}`,
+                        id: `%g.json.${lowerer.globalsList.length}`,
                         name: clause.name.text,
                         type: mapped,
                         mutable: false,
                     };
-                    L.globalsBySymbol.set(target, g);
-                    L.globalsList.push(g);
+                    lowerer.globalsBySymbol.set(target, g);
+                    lowerer.globalsList.push(g);
                 }
-                const actions = L.jsonInitActions.get(fp.sf) ?? [];
-                L.jsonInitActions.set(fp.sf, actions);
+                const actions = lowerer.jsonInitActions.get(fp.sf) ?? [];
+                lowerer.jsonInitActions.set(fp.sf, actions);
                 actions.push({ kind: "assign", localId: g.id, value, loc: locOf(stmt) });
             }
             catch (e) {
@@ -558,7 +559,7 @@ export function collectJsonImports(L, parts) {
    * deferred: the reference flushes those diagnostics. Methods whose
    * bodies were not lowered leave the def's method list, so vtable slots
    * exist exactly for emitted overrides. */
-export function moduleArtifacts(L, functions) {
+export function moduleArtifacts(lowerer, functions) {
     const classNames = new Set();
     const shapeIds = new Set();
     const unionIds = new Set();
@@ -592,7 +593,7 @@ export function moduleArtifacts(L, functions) {
         }
     };
     visit(functions);
-    visit(L.globalsList);
+    visit(lowerer.globalsList);
     // The builtin error classes ride EVERY module: the runtime's own throws
     // (JSON/dynCheck/regex failures) mint instances of them whether or not
     // user code mentions Error, and the uncaught printer tells Error
@@ -612,26 +613,26 @@ export function moduleArtifacts(L, functions) {
             // Declared fields AND the index-signature value type: an
             // overflow-valued shape (`{ [key: string]: {script?: string} }`)
             // references its value shape through indexValue alone.
-            const shape = L.shapes.get(pendingShapes.pop());
+            const shape = lowerer.shapes.get(pendingShapes.pop());
             visit(shape?.fields);
             if (shape?.indexValue)
                 visit(shape.indexValue);
         }
         while (pendingUnions.length > 0)
-            visit(L.unions.get(pendingUnions.pop())?.arms);
+            visit(lowerer.unions.get(pendingUnions.pop())?.arms);
         while (pendingClasses.length > 0) {
             const name = pendingClasses.pop();
-            const info = L.classes.get(name);
+            const info = lowerer.classes.get(name);
             if (!info) {
                 // Referenced by an emitted type but never registered: collection
                 // deferred its diagnostics — a reached reference makes them count.
-                L.flushDeferredClass(name);
+                lowerer.flushDeferredClass(name);
                 continue;
             }
             visit(info.def.fields);
             if (info.base)
                 visit([{ className: info.base.def.name }]);
-            if (L.inHierarchy(info)) {
+            if (lowerer.inHierarchy(info)) {
                 let root = info;
                 while (root.base)
                     root = root.base;
@@ -644,9 +645,9 @@ export function moduleArtifacts(L, functions) {
             }
         }
     }
-    const reachable = L.reachableForArtifacts ?? L.reachable;
+    const reachable = lowerer.reachableForArtifacts ?? lowerer.reachable;
     return {
-        classes: [...L.classes.values()]
+        classes: [...lowerer.classes.values()]
             .map((c) => c.def)
             .filter((def) => classNames.has(def.name))
             .map((def) => {
@@ -670,8 +671,8 @@ export function moduleArtifacts(L, functions) {
                 ...(abstractMethods.length > 0 ? { abstractMethods } : {}),
             };
         }),
-        records: L.shapes.shapes.filter((r) => shapeIds.has(r.id)),
-        unions: L.unions.unions.filter((u) => unionIds.has(u.id)),
+        records: lowerer.shapes.shapes.filter((r) => shapeIds.has(r.id)),
+        unions: lowerer.unions.unions.filter((u) => unionIds.has(u.id)),
     };
 }
 /** Registers every DIRECT top-level `const`/`let` of a file as a module
@@ -679,18 +680,18 @@ export function moduleArtifacts(L, functions) {
    * reference them without capture). Block-scoped vars inside nested
    * statements keep their different symbols and stay locals. */
 /** JS collection failures defer to runtime fences: the registration's
-* diagnostics move off the build (into L.runtimeFences) — the declaring
+* diagnostics move off the build (into lowerer.runtimeFences) — the declaring
 * statement re-fails during init lowering and compiles to the
 * runtimeFence trap there, and every use site cascades to its own trap.
 * TypeScript files keep eager collection reports. */
-function deferJsCollectionDiags(L, sf, diagsBefore) {
+function deferJsCollectionDiags(lowerer, sf, diagsBefore) {
     if (!isJsSourceFile(sf))
         return;
-    const captured = L.diags.splice(diagsBefore);
+    const captured = lowerer.diags.splice(diagsBefore);
     const ice = captured.filter((d) => d.code === "SC9001");
     if (ice.length > 0)
-        L.diags.push(...ice);
-    L.runtimeFences.push(...captured.filter((d) => d.code !== "SC9001"));
+        lowerer.diags.push(...ice);
+    lowerer.runtimeFences.push(...captured.filter((d) => d.code !== "SC9001"));
 }
 /** A scalar-literal expression a single-value `module.exports =` can carry
  * without any declaration to alias to: string/number/boolean literals,
@@ -712,7 +713,7 @@ function cjsScalarLiteral(e) {
  * an expando class member constructs a TYPED instance — corpus 2032), as
  * does everything else (object/array literals have their own rules;
  * typed-but-unmappable initializers keep the %init-local adoption). */
-function jsDynHoldableInitializer(L, init) {
+function jsDynHoldableInitializer(lowerer, init) {
     if (init === undefined)
         return true;
     let e = init;
@@ -723,7 +724,7 @@ function jsDynHoldableInitializer(L, init) {
     if (ts.isIdentifier(e) && e.text === "undefined")
         return true;
     if ((ts.isCallExpression(e) || ts.isPropertyAccessExpression(e) || ts.isIdentifier(e)) &&
-        (L.typeOf(e).flags & ts.TypeFlags.Any) !== 0) {
+        (lowerer.typeOf(e).flags & ts.TypeFlags.Any) !== 0) {
         return true;
     }
     // A CALL whose inferred type has no static mapping and whose residue
@@ -735,22 +736,22 @@ function jsDynHoldableInitializer(L, init) {
     // idiom. Non-dyn residues (pure single-signature function types, typed
     // arrays) keep their static stories.
     if (ts.isCallExpression(e)) {
-        const t = L.typeOf(e);
-        if (L.mapTypeOf(t) === null && dynFallbackType(L, e, t)?.kind === "dyn")
+        const t = lowerer.typeOf(e);
+        if (lowerer.mapTypeOf(t) === null && dynFallbackType(lowerer, e, t)?.kind === "dyn")
             return true;
     }
     return false;
 }
-export function collectGlobals(L, sf, topStmts) {
+export function collectGlobals(lowerer, sf, topStmts) {
     // Segment-tagged so mangled names can't collide across files (user
     // identifiers cannot contain '.'): entry globals "e.<name>", others
     // "m<i>.<name>".
-    const rawTag = L.fileTag.get(sf) ?? "";
+    const rawTag = lowerer.fileTag.get(sf) ?? "";
     const tag = rawTag === "" ? "e." : rawTag.replace(/^%/, "");
     // Expando function members (`foo.bar = 12` anywhere in the file)
     // register their module globals first — reads inside function bodies
     // collected earlier in this pass must resolve them (lower-expando.ts).
-    collectExpandoMembers(L, sf);
+    collectExpandoMembers(lowerer, sf);
     for (const stmt of topStmts) {
         // `export default <expr>`: the module's `default` binding is a const
         // module global (registered under the checker's default-export
@@ -777,12 +778,12 @@ export function collectGlobals(L, sf, topStmts) {
         // resolveValueSymbol's default-snapshot walk instead of chasing the
         // alias to the live let.
         if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
-            const symbol = defaultExportSymbolOf(L, sf);
+            const symbol = defaultExportSymbolOf(lowerer, sf);
             if (!symbol)
                 continue;
             if (symbol.flags & ts.SymbolFlags.Alias) {
-                const target = L.checker.getAliasedSymbol(symbol);
-                const vd = L.checker.valueDeclarationOf(target);
+                const target = lowerer.checker.getAliasedSymbol(symbol);
+                const vd = lowerer.checker.valueDeclarationOf(target);
                 const mutableVar = vd !== undefined &&
                     ts.isVariableDeclaration(vd) &&
                     !vd.getSourceFile().isDeclarationFile &&
@@ -807,31 +808,31 @@ export function collectGlobals(L, sf, topStmts) {
                 if (ts.isClassExpression(inner) && !isJsSourceFile(sf) &&
                     inner.typeParameters === undefined &&
                     (decoratorNodesOf(inner).length > 0 || inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
-                    guaranteedDecorationThrow(L, inner) !== null) {
+                    guaranteedDecorationThrow(lowerer, inner) !== null) {
                     continue;
                 }
             }
             try {
-                let tsType = L.typeOf(stmt.expression);
+                let tsType = lowerer.typeOf(stmt.expression);
                 // tsgo answers `any` at some export-assignment EXPRESSION
                 // positions (a bare literal default) — the SYMBOL's type is the
                 // declared truth and serves as the fallback.
                 if (tsType.flags & ts.TypeFlags.Any) {
-                    const symType = L.checker.getTypeOfSymbol(symbol);
+                    const symType = lowerer.checker.getTypeOfSymbol(symbol);
                     if (!(symType.flags & ts.TypeFlags.Any))
                         tsType = symType;
                 }
-                let type = L.mapTypeOf(tsType) ?? dynFallbackType(L, stmt.expression, tsType) ?? L.badType(stmt.expression, tsType);
+                let type = lowerer.mapTypeOf(tsType) ?? dynFallbackType(lowerer, stmt.expression, tsType) ?? lowerer.badType(stmt.expression, tsType);
                 // `export default undefined` — the unit-only union, like any
                 // unit-only binding (`export default null` maps via mapType).
                 if (type.kind === "void" && isUnitOnlyTsType(tsType)) {
-                    type = unitOnlyUnion(L.unions);
+                    type = unitOnlyUnion(lowerer.unions);
                 }
                 if (type.kind === "void")
-                    L.badType(stmt.expression, tsType);
+                    lowerer.badType(stmt.expression, tsType);
                 const g = { id: `%g.${tag}default`, name: "default", type, mutable: false };
-                L.globalsBySymbol.set(symbol, g);
-                L.globalsList.push(g);
+                lowerer.globalsBySymbol.set(symbol, g);
+                lowerer.globalsList.push(g);
             }
             catch (e) {
                 if (!(e instanceof PoisonError))
@@ -854,22 +855,22 @@ export function collectGlobals(L, sf, topStmts) {
             // importers never see. The statement lowering owns the diagnostic.
             const cjs = cjsExportDiscardReason(stmt) === null ? cjsExportAssignmentOf(stmt) : null;
             const registerExport = (nameNode, name, typeNode) => {
-                const diagsBefore = L.diags.length;
+                const diagsBefore = lowerer.diags.length;
                 try {
                     // tsgo answers no symbol at the attachment site's NAME (no
                     // expando synthesis); the module symbol's exports table still
                     // names the member — the same identity use sites resolve.
-                    const symbol = L.checker.getSymbolAtLocation(nameNode) ?? L.cjsModuleExportSymbol(sf, name);
-                    if (!symbol || L.globalsBySymbol.has(symbol))
+                    const symbol = lowerer.checker.getSymbolAtLocation(nameNode) ?? lowerer.cjsModuleExportSymbol(sf, name);
+                    if (!symbol || lowerer.globalsBySymbol.has(symbol))
                         return;
                     // JS exports whose strict type has no mapping take the
                     // checked-dynamic fallback (implicit-any function exports —
                     // common/tls's `exports.check = function (certs) {...}` —
                     // keep func-ness with dyn pieces; everything else is dyn).
-                    const strict = L.checker.getTypeOfSymbol(symbol);
-                    const t = L.mapTypeOf(strict) ?? dynFallbackType(L, nameNode, strict);
+                    const strict = lowerer.checker.getTypeOfSymbol(symbol);
+                    const t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict);
                     if (!t || t.kind === "void")
-                        L.badType(typeNode, strict);
+                        lowerer.badType(typeNode, strict);
                     // `module.exports.Strings = Strings` naming a dyn-HOLDING
                     // const (the JS file-scope object-literal identity story): the
                     // export ALIASES the const's own dyn global — one storage, one
@@ -885,13 +886,13 @@ export function collectGlobals(L, sf, topStmts) {
                         while (ts.isParenthesizedExpression(rhs))
                             rhs = rhs.expression;
                         if (ts.isIdentifier(rhs)) {
-                            const vSym = L.checker.getSymbolAtLocation(rhs);
-                            const vG = vSym && L.globalsBySymbol.get(vSym);
+                            const vSym = lowerer.checker.getSymbolAtLocation(rhs);
+                            const vG = vSym && lowerer.globalsBySymbol.get(vSym);
                             if (vG?.type.kind === "dyn") {
                                 if (!vG.mutable) {
-                                    L.globalsBySymbol.set(symbol, vG);
-                                    for (const d of L.checker.declarationsOf(symbol))
-                                        L.globalsByDeclNode.set(d, vG);
+                                    lowerer.globalsBySymbol.set(symbol, vG);
+                                    for (const d of lowerer.checker.declarationsOf(symbol))
+                                        lowerer.globalsByDeclNode.set(d, vG);
                                     return;
                                 }
                                 // A mutable (`let`) dyn source: separate DYN storage IS
@@ -900,28 +901,28 @@ export function collectGlobals(L, sf, topStmts) {
                                 // export). The id must not collide with the let's own
                                 // `%g.<tag><name>` global.
                                 const g = { id: `%g.${tag}%export.${name}`, name, type: DYN, mutable: false };
-                                L.globalsBySymbol.set(symbol, g);
-                                for (const d of L.checker.declarationsOf(symbol))
-                                    L.globalsByDeclNode.set(d, g);
-                                L.globalsList.push(g);
+                                lowerer.globalsBySymbol.set(symbol, g);
+                                for (const d of lowerer.checker.declarationsOf(symbol))
+                                    lowerer.globalsByDeclNode.set(d, g);
+                                lowerer.globalsList.push(g);
                                 return;
                             }
                         }
                     }
                     const g = { id: `%g.${tag}${name}`, name, type: t, mutable: false };
-                    L.globalsBySymbol.set(symbol, g);
+                    lowerer.globalsBySymbol.set(symbol, g);
                     // Importer aliases resolve to a DISTINCT late-bound symbol with
                     // the same declaration — key the node too (globalOf's fallback).
-                    for (const d of L.checker.declarationsOf(symbol))
-                        L.globalsByDeclNode.set(d, g);
-                    L.globalsList.push(g);
+                    for (const d of lowerer.checker.declarationsOf(symbol))
+                        lowerer.globalsByDeclNode.set(d, g);
+                    lowerer.globalsList.push(g);
                 }
                 catch (e) {
                     if (!(e instanceof PoisonError))
                         throw e;
                     // diagnostic recorded; the statement lowering poisons too —
                     // both defer to the statement's runtime fence in JS files.
-                    deferJsCollectionDiags(L, sf, diagsBefore);
+                    deferJsCollectionDiags(lowerer, sf, diagsBefore);
                 }
             };
             if (cjs?.kind === "member" && ts.isIdentifier(cjs.name)) {
@@ -930,7 +931,7 @@ export function collectGlobals(L, sf, topStmts) {
                 // builtin-derived classes); importers re-resolve to the class
                 // symbol (cjsMemberExportClassSymbol) and the class registry
                 // applies unchanged.
-                if (L.cjsMemberExportClassSymbol(cjs.expr) !== null)
+                if (lowerer.cjsMemberExportClassSymbol(cjs.expr) !== null)
                     continue;
                 registerExport(cjs.name, cjs.name.text, cjs.value);
                 continue;
@@ -958,20 +959,20 @@ export function collectGlobals(L, sf, topStmts) {
                 // fallback like every JS binding.
                 const fnValued = ts.isFunctionExpression(rhs) || ts.isArrowFunction(rhs);
                 if (cjsScalarLiteral(rhs) || fnValued) {
-                    const diagsBefore = L.diags.length;
+                    const diagsBefore = lowerer.diags.length;
                     try {
-                        const strict = L.typeOf(rhs);
-                        const t = L.mapTypeOf(strict) ?? (fnValued ? dynFallbackType(L, rhs, strict) : null);
+                        const strict = lowerer.typeOf(rhs);
+                        const t = lowerer.mapTypeOf(strict) ?? (fnValued ? dynFallbackType(lowerer, rhs, strict) : null);
                         if (t && t.kind !== "void") {
                             const g = { id: `%g.${tag}exports`, name: "exports", type: t, mutable: false };
-                            L.globalsByDeclNode.set(cjs.expr, g);
-                            L.globalsList.push(g);
+                            lowerer.globalsByDeclNode.set(cjs.expr, g);
+                            lowerer.globalsList.push(g);
                         }
                     }
                     catch (e) {
                         if (!(e instanceof PoisonError))
                             throw e;
-                        deferJsCollectionDiags(L, sf, diagsBefore);
+                        deferJsCollectionDiags(lowerer, sf, diagsBefore);
                     }
                 }
                 continue;
@@ -1003,38 +1004,38 @@ export function collectGlobals(L, sf, topStmts) {
         if (ts.isImportEqualsDeclaration(stmt)) {
             if (ts.isExternalModuleReference(stmt.moduleReference) || stmt.isTypeOnly)
                 continue;
-            const aliasSym = L.checker.getSymbolAtLocation(stmt.name);
-            if (!aliasSym || !(aliasSym.flags & ts.SymbolFlags.Alias) || L.globalsBySymbol.has(aliasSym))
+            const aliasSym = lowerer.checker.getSymbolAtLocation(stmt.name);
+            if (!aliasSym || !(aliasSym.flags & ts.SymbolFlags.Alias) || lowerer.globalsBySymbol.has(aliasSym))
                 continue;
-            const target = L.checker.getAliasedSymbol(aliasSym);
-            const vd = L.checker.valueDeclarationOf(target);
+            const target = lowerer.checker.getAliasedSymbol(aliasSym);
+            const vd = lowerer.checker.valueDeclarationOf(target);
             const mutableVar = vd !== undefined &&
                 ts.isVariableDeclaration(vd) &&
                 !vd.getSourceFile().isDeclarationFile &&
                 (ts.getCombinedNodeFlags(vd) & ts.NodeFlags.Const) === 0;
             if (!mutableVar)
                 continue;
-            const diagsBefore = L.diags.length;
+            const diagsBefore = lowerer.diags.length;
             try {
-                let type = L.irTypeOf(stmt.name);
-                if (type.kind === "void" && isUnitOnlyTsType(L.typeOf(stmt.name))) {
-                    type = unitOnlyUnion(L.unions);
+                let type = lowerer.irTypeOf(stmt.name);
+                if (type.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(stmt.name))) {
+                    type = unitOnlyUnion(lowerer.unions);
                 }
                 if (type.kind === "void")
-                    L.badType(stmt.name, L.typeOf(stmt.name));
+                    lowerer.badType(stmt.name, lowerer.typeOf(stmt.name));
                 const g = {
                     id: `%g.${tag}${nsPathPrefix(stmt)}%alias.${stmt.name.text}%${stmt.getStart()}`,
                     name: stmt.name.text,
                     type,
                     mutable: false,
                 };
-                L.globalsBySymbol.set(aliasSym, g);
-                L.globalsList.push(g);
+                lowerer.globalsBySymbol.set(aliasSym, g);
+                lowerer.globalsList.push(g);
             }
             catch (e) {
                 if (!(e instanceof PoisonError))
                     throw e;
-                deferJsCollectionDiags(L, sf, diagsBefore);
+                deferJsCollectionDiags(lowerer, sf, diagsBefore);
             }
             continue;
         }
@@ -1045,7 +1046,7 @@ export function collectGlobals(L, sf, topStmts) {
         // statements continue into the main registration below, which also
         // owns the special forms — requires, aliases, promisify).
         if (!ts.isVariableStatement(stmt)) {
-            collectNestedVarGlobals(L, sf, stmt, tag);
+            collectNestedVarGlobals(lowerer, sf, stmt, tag);
             continue;
         }
         // CommonJS require declarations are alias plumbing (preflight owns
@@ -1059,7 +1060,7 @@ export function collectGlobals(L, sf, topStmts) {
             if (ts.isVariableStatement(stmt) &&
                 (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
                 for (const decl of stmt.declarationList.declarations) {
-                    stdlibGlobalAliasDecl(L, decl.name, decl.initializer);
+                    stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer);
                 }
             }
             continue;
@@ -1091,7 +1092,7 @@ export function collectGlobals(L, sf, topStmts) {
             // provenanceElidedConstDecl). Checked FIRST: the mixin/promisify
             // probes below would otherwise claim the call-initializer shape
             // and put its fences on the build.
-            if (provenanceElidedConstDecl(L, decl))
+            if (provenanceElidedConstDecl(lowerer, decl))
                 continue;
             // A stored built-in numeric value iterator has no first-class
             // global representation. Its same-%init for-of uses are backed by
@@ -1101,7 +1102,7 @@ export function collectGlobals(L, sf, topStmts) {
             // Cross-function or exported uses still fence at reference sites.
             if (isConst &&
                 ts.isIdentifier(decl.name) &&
-                numericIteratorSourceOf(L, decl.initializer) !== null) {
+                numericIteratorSourceOf(lowerer, decl.initializer) !== null) {
                 continue;
             }
             // The trap/nullish/dead classification probes below resolve
@@ -1113,7 +1114,7 @@ export function collectGlobals(L, sf, topStmts) {
             // registration, and the statement lowering re-fences at its own
             // site (pushDiag dedupes), exactly the per-probe recovery the
             // alias/generic-fn registrations below already use.
-            const classifyDiagsBefore = L.diags.length;
+            const classifyDiagsBefore = lowerer.diags.length;
             const classified = (() => {
                 try {
                     // A TRAP declaration at file scope — the initializer's chain roots
@@ -1125,11 +1126,11 @@ export function collectGlobals(L, sf, topStmts) {
                     // lowers, so hoisted-function references resolve the trap), and
                     // the statement lowering emits the throw at its position.
                     // Written bindings keep ordinary storage (trapDeclRootOf).
-                    if (trapDeclRootOf(L, decl) !== null) {
+                    if (trapDeclRootOf(lowerer, decl) !== null) {
                         for (const nameNode of boundIdentifiersOf(decl.name)) {
-                            const sym = L.checker.getSymbolAtLocation(nameNode);
+                            const sym = lowerer.checker.getSymbolAtLocation(nameNode);
                             if (sym)
-                                L.trapBindings.add(sym);
+                                lowerer.trapBindings.add(sym);
                         }
                         return true;
                     }
@@ -1138,14 +1139,14 @@ export function collectGlobals(L, sf, topStmts) {
                     // value (lower-exprs/lower-calls claim them); the statement
                     // lowering emits nothing by the same test.
                     if (ts.isIdentifier(decl.name) &&
-                        nullishGenericBindingUnitOf(L, L.checker.getSymbolAtLocation(decl.name) ?? null) !== null) {
+                        nullishGenericBindingUnitOf(lowerer, lowerer.checker.getSymbolAtLocation(decl.name) ?? null) !== null) {
                         return true;
                     }
                     // A DEAD unmappable binding at file scope (`var xs2: typeof
                     // Array;` — never read anywhere): no global, no statement, no
                     // type fence for a value the program never consumes.
                     if (ts.isIdentifier(decl.name) &&
-                        deadUnmappableBinding(L, L.checker.getSymbolAtLocation(decl.name) ?? null, decl)) {
+                        deadUnmappableBinding(lowerer, lowerer.checker.getSymbolAtLocation(decl.name) ?? null, decl)) {
                         return true;
                     }
                 }
@@ -1157,7 +1158,7 @@ export function collectGlobals(L, sf, topStmts) {
                     // collection failure; TS keeps the eager report (the
                     // statement lowering re-fences at its own site — pushDiag
                     // dedupes).
-                    deferJsCollectionDiags(L, sf, classifyDiagsBefore);
+                    deferJsCollectionDiags(lowerer, sf, classifyDiagsBefore);
                 }
                 return false;
             })();
@@ -1172,10 +1173,10 @@ export function collectGlobals(L, sf, topStmts) {
             // by name; the statement lowering skips (or re-fences — pushDiag
             // dedupes) by the same test.
             {
-                const gfnNode = bindingGenericFnNodeOf(decl) ?? bindingContextualGenericFnNodeOf(L, decl);
+                const gfnNode = bindingGenericFnNodeOf(decl) ?? bindingContextualGenericFnNodeOf(lowerer, decl);
                 if (gfnNode) {
                     try {
-                        bindingGenericFnInfoOf(L, decl, gfnNode);
+                        bindingGenericFnInfoOf(lowerer, decl, gfnNode);
                     }
                     catch (e) {
                         if (!(e instanceof PoisonError))
@@ -1193,7 +1194,7 @@ export function collectGlobals(L, sf, topStmts) {
             {
                 let aliased = false;
                 try {
-                    aliased = bindingGenericFnAliasInfoOf(L, decl) !== null;
+                    aliased = bindingGenericFnAliasInfoOf(lowerer, decl) !== null;
                 }
                 catch (e) {
                     if (!(e instanceof PoisonError))
@@ -1209,9 +1210,9 @@ export function collectGlobals(L, sf, topStmts) {
             // value references resolve through genericFnsBySymbol, and the
             // statement lowering skips by the same test.
             {
-                const implicitNode = implicitLocalFnNodeOf(L, decl);
+                const implicitNode = implicitLocalFnNodeOf(lowerer, decl);
                 if (implicitNode) {
-                    implicitLocalFnInfoOf(L, decl, implicitNode);
+                    implicitLocalFnInfoOf(lowerer, decl, implicitNode);
                     continue;
                 }
             }
@@ -1220,7 +1221,7 @@ export function collectGlobals(L, sf, topStmts) {
             // branch above): no global exists — calls instantiate the class
             // inside per site (lower-mixins.ts); the statement lowering skips
             // by the same test.
-            if (isMixinFnBinding(L, decl))
+            if (isMixinFnBinding(lowerer, decl))
                 continue;
             // `const Thing1 = Tagged(Derived)` — a mixin RESULT binding: the
             // binding provably holds that one call's class object forever
@@ -1236,9 +1237,9 @@ export function collectGlobals(L, sf, topStmts) {
                 while (ts.isParenthesizedExpression(init))
                     init = init.expression;
                 if (ts.isCallExpression(init)) {
-                    const bindSym = L.checker.getSymbolAtLocation(decl.name);
+                    const bindSym = lowerer.checker.getSymbolAtLocation(decl.name);
                     try {
-                        if (mixinResultBindingClassOf(L, bindSym))
+                        if (mixinResultBindingClassOf(lowerer, bindSym))
                             continue;
                     }
                     catch (e) {
@@ -1254,9 +1255,9 @@ export function collectGlobals(L, sf, topStmts) {
             // statement lowering skips the declaration by the same check. A
             // bad promisify target reports here (recorded once; the statement
             // lowering poisons too, like every collectGlobals failure).
-            if (ts.isIdentifier(decl.name) && decl.initializer && isPromisifyCall(L, decl.initializer)) {
+            if (ts.isIdentifier(decl.name) && decl.initializer && isPromisifyCall(lowerer, decl.initializer)) {
                 try {
-                    L.promisifiedExecFileDecl(decl.name, decl.initializer);
+                    lowerer.promisifiedExecFileDecl(decl.name, decl.initializer);
                 }
                 catch (e) {
                     if (!(e instanceof PoisonError))
@@ -1273,45 +1274,45 @@ export function collectGlobals(L, sf, topStmts) {
             // `const require = createRequire(import.meta.url)` at file scope:
             // compile-time plumbing — no global storage; the statement
             // lowering skips it by the same test.
-            if (isConst && createRequireBindingDecl(L, decl.name, decl.initializer))
+            if (isConst && createRequireBindingDecl(lowerer, decl.name, decl.initializer))
                 continue;
             // `const fs = require("node:fs")` through that binding at file
             // scope — a namespace import in const clothing, same story.
-            if (isConst && createRequireNamespaceDecl(L, decl.name, decl.initializer))
+            if (isConst && createRequireNamespaceDecl(lowerer, decl.name, decl.initializer))
                 continue;
             // `const { createSign } = crypto` over a builtin NAMESPACE binding
             // at file scope: alias plumbing like the destructured-require form
             // — no storage (the statement lowering skips by the same test).
-            if (builtinNamespaceDestructureModuleOf(L, decl) !== null)
+            if (builtinNamespaceDestructureModuleOf(lowerer, decl) !== null)
                 continue;
             // `const { NGHTTP2_CANCEL } = http2.constants` at file scope: a
             // destructure over the baked constants table — alias plumbing, no
             // global storage (the statement lowering skips it by the same
             // test).
-            if (L.builtinConstantsDestructureDecl(decl.name, decl.initializer))
+            if (lowerer.builtinConstantsDestructureDecl(decl.name, decl.initializer))
                 continue;
             // `const Writable = stream.Writable` at file scope: a stream
             // class through the namespace binding — alias plumbing, no
             // global storage (the statement lowering skips it by the same
             // test).
-            if (isConst && streamClassAliasDecl(L, decl.name, decl.initializer))
+            if (isConst && streamClassAliasDecl(lowerer, decl.name, decl.initializer))
                 continue;
             // `const process = globalThis.process` at file scope: a stdlib-
             // global snapshot — alias plumbing, no global storage (see
             // stdlibGlobalAliasDecl; the statement lowering skips it by the
             // same test).
-            if (isConst && stdlibGlobalAliasDecl(L, decl.name, decl.initializer))
+            if (isConst && stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer))
                 continue;
             // Stored default TextEncoder/TextDecoder instances are the same
             // compile-time alias plumbing as their statement lowering: calls
             // trace this const initializer, so no module global exists.
-            if (isConst && textCodecBindingDecl(L, decl.name, decl.initializer))
+            if (isConst && textCodecBindingDecl(lowerer, decl.name, decl.initializer))
                 continue;
             // Destructuring declarations register EVERY bound identifier (the
             // desugar in the init function assigns the pre-registered globals,
             // exactly like plain declarations).
             for (const nameNode of boundIdentifiersOf(decl.name)) {
-                const diagsBefore = L.diags.length;
+                const diagsBefore = lowerer.diags.length;
                 try {
                     // A JS file-scope evolving ARRAY (`const mustCallChecks = [];`
                     // — test/common's exit-accounting ledger): the strict type
@@ -1322,14 +1323,14 @@ export function collectGlobals(L, sf, topStmts) {
                     // storage instead of fencing per reference. Identifier
                     // declarations only: a destructured array literal binds its
                     // pieces, not the array.
-                    if (isJsSourceFile(sf) && !L.mapTypeOf(L.typeOf(nameNode)) &&
+                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name &&
                         decl.initializer !== undefined && ts.isArrayLiteralExpression(decl.initializer)) {
-                        const symbol = L.checker.getSymbolAtLocation(nameNode);
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol) {
                             const g = { id: `%g.${tag}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet };
-                            L.globalsBySymbol.set(symbol, g);
-                            L.globalsList.push(g);
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
                         }
                         continue;
                     }
@@ -1353,15 +1354,15 @@ export function collectGlobals(L, sf, topStmts) {
                         decl.initializer.properties.every((p) => {
                             if (!ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name))
                                 return false;
-                            const mt = L.mapTypeOf(L.typeOf(p.initializer));
+                            const mt = lowerer.mapTypeOf(lowerer.typeOf(p.initializer));
                             return mt === null || mt.kind === "dyn" ||
-                                canConvertToDyn(mt, (id) => L.shapes.get(id), (id) => L.unions.get(id));
+                                canConvertToDyn(mt, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id));
                         })) {
-                        const symbol = L.checker.getSymbolAtLocation(nameNode);
-                        if (symbol && !L.globalsBySymbol.has(symbol)) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = { id: `%g.${tag}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet };
-                            L.globalsBySymbol.set(symbol, g);
-                            L.globalsList.push(g);
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
                         }
                         continue;
                     }
@@ -1378,21 +1379,21 @@ export function collectGlobals(L, sf, topStmts) {
                     // decl keeps as an %init local) stay OUT: forcing those into
                     // the checked-dynamic tree would trade their working typed representation for
                     // fences.
-                    if (isJsSourceFile(sf) && !L.mapTypeOf(L.typeOf(nameNode)) &&
+                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name &&
-                        jsDynHoldableInitializer(L, decl.initializer) &&
-                        dynFallbackType(L, nameNode, L.typeOf(nameNode))?.kind === "dyn") {
-                        const symbol = L.checker.getSymbolAtLocation(nameNode);
-                        if (symbol && !L.globalsBySymbol.has(symbol)) {
+                        jsDynHoldableInitializer(lowerer, decl.initializer) &&
+                        dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode))?.kind === "dyn") {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet };
-                            L.globalsBySymbol.set(symbol, g);
-                            L.globalsList.push(g);
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
                             // Mutable dyn globals hold the dyn undefined from module
                             // entry (the main path's rule below): a closure called
                             // above the declaration reads undefined instead of
                             // faulting on NULL.
                             if (g.mutable)
-                                noteVarGlobalEntryInit(L, sf, g);
+                                noteVarGlobalEntryInit(lowerer, sf, g);
                         }
                         continue;
                     }
@@ -1403,15 +1404,15 @@ export function collectGlobals(L, sf, topStmts) {
                     // the binding holds the HANDLE — a jsval global, so exports
                     // and separately-declared functions reach the same engine
                     // object.
-                    if (L.dynamic && isJsSourceFile(sf) && !L.mapTypeOf(L.typeOf(nameNode)) &&
+                    if (lowerer.dynamic && isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name &&
                         decl.initializer !== undefined && ts.isObjectLiteralExpression(decl.initializer) &&
                         decl.initializer.properties.some((p) => ts.isGetAccessorDeclaration(p))) {
-                        const symbol = L.checker.getSymbolAtLocation(nameNode);
-                        if (symbol && !L.globalsBySymbol.has(symbol)) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: JSVAL, mutable: isLet };
-                            L.globalsBySymbol.set(symbol, g);
-                            L.globalsList.push(g);
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
                         }
                         continue;
                     }
@@ -1422,20 +1423,20 @@ export function collectGlobals(L, sf, topStmts) {
                     // and closures created in the init body capture it normally.
                     // References from separately-declared functions cascade to
                     // their own per-site runtime fences.
-                    if (isJsSourceFile(sf) && !L.mapTypeOf(L.typeOf(nameNode)))
+                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
                         continue;
                     // `var p1 = import("./m")` at file scope: the global holds the
                     // island promise/handle — the import expression's only
                     // production — whatever the checker's namespace type mapped to
                     // (lowerVarDecl's rule at module scope; the init body assigns
                     // it).
-                    const handleT = L.dynamic && ts.isIdentifier(decl.name) && nameNode === decl.name
+                    const handleT = lowerer.dynamic && ts.isIdentifier(decl.name) && nameNode === decl.name
                         ? (importCallHandleType(decl.initializer) ??
                             // An unchecked-overload call result stores the handle,
                             // exactly the local rule (uncheckedOverloadHandleCall).
-                            (uncheckedOverloadHandleCall(L, decl.initializer) ? JSVAL : null))
+                            (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null))
                         : null;
-                    let type = handleT ?? L.irTypeOf(nameNode);
+                    let type = handleT ?? lowerer.irTypeOf(nameNode);
                     // An evolving-`any` array's DERIVED file-scope binding under
                     // --dynamic (`const kept = fns.filter(...)` where `fns`
                     // registered array<jsval> at its `any[]` declaration): the
@@ -1446,10 +1447,10 @@ export function collectGlobals(L, sf, topStmts) {
                     // element array (lowerVarDecl's adoption, the file-scope
                     // face). Annotated declarations keep the validated-boundary
                     // fence.
-                    if (L.dynamic && ts.isIdentifier(decl.name) && nameNode === decl.name &&
+                    if (lowerer.dynamic && ts.isIdentifier(decl.name) && nameNode === decl.name &&
                         decl.type === undefined && decl.initializer !== undefined &&
                         type.kind === "array" && type.elem.kind !== "jsval" &&
-                        handleArrayPreservingCall(L, decl.initializer)) {
+                        handleArrayPreservingCall(lowerer, decl.initializer)) {
                         type = arrayOf(JSVAL);
                     }
                     // `const r: Repo = new MemRepo()` over an all-generic-method
@@ -1458,8 +1459,8 @@ export function collectGlobals(L, sf, topStmts) {
                     // copy would drop the class the generic-method calls
                     // monomorphize against) — see genericIfaceBindingKeepsClass.
                     if (type.kind === "record" && ts.isIdentifier(decl.name) && nameNode === decl.name &&
-                        genericIfaceBindingKeepsClass(L, decl, type)) {
-                        const initT = L.mapTypeOf(L.typeOf(decl.initializer));
+                        genericIfaceBindingKeepsClass(lowerer, decl, type)) {
+                        const initT = lowerer.mapTypeOf(lowerer.typeOf(decl.initializer));
                         if (initT?.kind === "object")
                             type = initT;
                     }
@@ -1470,8 +1471,8 @@ export function collectGlobals(L, sf, topStmts) {
                     // primitives exit eagerly to their static type, everything
                     // else stores the HANDLE (a func-typed slot could never take
                     // the engine value the desugar assigns).
-                    if (L.dynamic && !ts.isIdentifier(decl.name) && decl.initializer !== undefined) {
-                        const srcT = L.mapTypeOf(L.typeOf(decl.initializer));
+                    if (lowerer.dynamic && !ts.isIdentifier(decl.name) && decl.initializer !== undefined) {
+                        const srcT = lowerer.mapTypeOf(lowerer.typeOf(decl.initializer));
                         const island = srcT !== null &&
                             (srcT.kind === "jsval" || srcT.kind === "f64" || srcT.kind === "bool" ||
                                 srcT.kind === "string" || isUnitType(srcT));
@@ -1482,11 +1483,11 @@ export function collectGlobals(L, sf, topStmts) {
                     // File-scope unit-only bindings (`var x: undefined`, `const
                     // y: void = undefined`) ride the unit-only union, exactly
                     // like function-scope locals (lowerVarDecl's rule).
-                    if (type.kind === "void" && isUnitOnlyTsType(L.typeOf(nameNode))) {
-                        type = unitOnlyUnion(L.unions);
+                    if (type.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(nameNode))) {
+                        type = unitOnlyUnion(lowerer.unions);
                     }
                     if (type.kind === "void")
-                        L.badType(nameNode, L.typeOf(nameNode));
+                        lowerer.badType(nameNode, lowerer.typeOf(nameNode));
                     // A JS file-scope FUNCTION binding whose unannotated return
                     // infers a record (`const wrapped = function () { return
                     // expectedResult; }`): the closure VALUE lowers with a dyn
@@ -1508,15 +1509,15 @@ export function collectGlobals(L, sf, topStmts) {
                     // type admits ANY later non-nullish assignment, so the static
                     // empty struct cannot hold the binding's future.
                     if (isLet && type.kind === "record" && isJsSourceFile(sf)) {
-                        const shape = L.shapes.get(type.shapeId);
+                        const shape = lowerer.shapes.get(type.shapeId);
                         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
                             type = DYN;
                     }
-                    const symbol = L.checker.getSymbolAtLocation(nameNode);
+                    const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                     // Merged `var` redeclarations (`var y = 1; ...; var y = 2;` —
                     // one symbol) register exactly one global; later declarations
                     // are plain assignments.
-                    if (!symbol || L.globalsBySymbol.has(symbol))
+                    if (!symbol || lowerer.globalsBySymbol.has(symbol))
                         continue;
                     const g = {
                         id: `%g.${tag}${nsPrefix}${nameNode.text}`,
@@ -1524,15 +1525,15 @@ export function collectGlobals(L, sf, topStmts) {
                         type,
                         mutable: isLet,
                     };
-                    L.globalsBySymbol.set(symbol, g);
-                    L.globalsList.push(g);
+                    lowerer.globalsBySymbol.set(symbol, g);
+                    lowerer.globalsList.push(g);
                     // Mutable checked-dynamic LET globals ride the same entry
                     // init: a closure called above the declaration statement
                     // reads the dyn undefined instead of faulting on NULL — the
                     // dyn face of let's documented pre-declaration window (Node
                     // throws the TDZ ReferenceError there).
                     if (isVarDeclared(decl) || (g.type.kind === "dyn" && g.mutable)) {
-                        noteVarGlobalEntryInit(L, sf, g);
+                        noteVarGlobalEntryInit(lowerer, sf, g);
                     }
                 }
                 catch (e) {
@@ -1541,7 +1542,7 @@ export function collectGlobals(L, sf, topStmts) {
                     // diagnostic already recorded; lowering the statement poisons
                     // too — and in a JS file BOTH defer to the statement's
                     // runtime fence (deferJsCollectionDiags).
-                    deferJsCollectionDiags(L, sf, diagsBefore);
+                    deferJsCollectionDiags(lowerer, sf, diagsBefore);
                 }
             }
         }
@@ -1554,7 +1555,7 @@ export function collectGlobals(L, sf, topStmts) {
    * answers the receiver's own array type). Registration runs in source
    * order, so the root's global — declared above, TDZ-guaranteed — is
    * already in the table. */
-function handleArrayPreservingCall(L, e) {
+function handleArrayPreservingCall(lowerer, e) {
     const PRESERVING = new Set(["filter", "slice", "splice", "concat"]);
     let cur = e;
     for (;;) {
@@ -1569,8 +1570,8 @@ function handleArrayPreservingCall(L, e) {
     }
     if (!ts.isIdentifier(cur))
         return false;
-    const sym = L.checker.getSymbolAtLocation(cur);
-    const g = sym ? L.globalsBySymbol.get(sym) : undefined;
+    const sym = lowerer.checker.getSymbolAtLocation(cur);
+    const g = sym ? lowerer.globalsBySymbol.get(sym) : undefined;
     return g?.type.kind === "array" && g.type.elem.kind === "jsval";
 }
 /** Registers the entry-init note for a `var` module global: JS hoists
@@ -1582,7 +1583,7 @@ function handleArrayPreservingCall(L, e) {
    * a value). Other types need nothing: tsc's flow analysis rejects their
    * direct early reads, and closure reads share let's documented
    * zero/NULL divergence window. */
-function noteVarGlobalEntryInit(L, sf, g) {
+function noteVarGlobalEntryInit(lowerer, sf, g) {
     // 'any' globals need the entry init exactly like undefined-armed
     // unions: tsc never guards `any` reads, so `var x: any;` is readable
     // before any assignment and its slot must hold its world's undefined
@@ -1591,9 +1592,9 @@ function noteVarGlobalEntryInit(L, sf, g) {
     // memory-unsafe, not a TypeError).
     if (g.type.kind !== "union" && g.type.kind !== "jsval" && g.type.kind !== "dyn")
         return;
-    const inits = L.varGlobalEntryInits.get(sf) ?? [];
+    const inits = lowerer.varGlobalEntryInits.get(sf) ?? [];
     inits.push(g);
-    L.varGlobalEntryInits.set(sf, inits);
+    lowerer.varGlobalEntryInits.set(sf, inits);
 }
 /** The nested half of module-scope `var` hoisting: a `var` inside a
    * top-level BLOCK (an if arm, a loop body, a try) is module-scoped in
@@ -1605,7 +1606,7 @@ function noteVarGlobalEntryInit(L, sf, g) {
    * scope). Registration mirrors the main path's identifier story:
    * JS-unmappable types register nothing (per-site fences own the
    * references), everything else gets a mutable global. */
-function collectNestedVarGlobals(L, sf, stmt, tag) {
+function collectNestedVarGlobals(lowerer, sf, stmt, tag) {
     const lists = [];
     // Iterative walk (walkPreorder): this sweep sees every non-var top-level
     // statement whole — the binderBinaryExpressionStress bare ~6500-term
@@ -1627,35 +1628,35 @@ function collectNestedVarGlobals(L, sf, stmt, tag) {
     for (const list of lists) {
         for (const decl of list.declarations) {
             for (const nameNode of boundIdentifiersOf(decl.name)) {
-                const diagsBefore = L.diags.length;
+                const diagsBefore = lowerer.diags.length;
                 try {
-                    if (isJsSourceFile(sf) && !L.mapTypeOf(L.typeOf(nameNode)))
+                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
                         continue;
-                    let type = L.irTypeOf(nameNode);
+                    let type = lowerer.irTypeOf(nameNode);
                     // Nested-var unit-only bindings take the unit-only union too
                     // (the top-level registration's rule).
-                    if (type.kind === "void" && isUnitOnlyTsType(L.typeOf(nameNode))) {
-                        type = unitOnlyUnion(L.unions);
+                    if (type.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(nameNode))) {
+                        type = unitOnlyUnion(lowerer.unions);
                     }
                     if (type.kind === "void")
-                        L.badType(nameNode, L.typeOf(nameNode));
+                        lowerer.badType(nameNode, lowerer.typeOf(nameNode));
                     if (type.kind === "record" && isJsSourceFile(sf)) {
-                        const shape = L.shapes.get(type.shapeId);
+                        const shape = lowerer.shapes.get(type.shapeId);
                         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
                             type = DYN;
                     }
-                    const symbol = L.checker.getSymbolAtLocation(nameNode);
-                    if (!symbol || L.globalsBySymbol.has(symbol))
+                    const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                    if (!symbol || lowerer.globalsBySymbol.has(symbol))
                         continue;
                     const g = { id: `%g.${tag}${nameNode.text}`, name: nameNode.text, type, mutable: true };
-                    L.globalsBySymbol.set(symbol, g);
-                    L.globalsList.push(g);
-                    noteVarGlobalEntryInit(L, sf, g);
+                    lowerer.globalsBySymbol.set(symbol, g);
+                    lowerer.globalsList.push(g);
+                    noteVarGlobalEntryInit(lowerer, sf, g);
                 }
                 catch (e) {
                     if (!(e instanceof PoisonError))
                         throw e;
-                    deferJsCollectionDiags(L, sf, diagsBefore);
+                    deferJsCollectionDiags(lowerer, sf, diagsBefore);
                 }
             }
         }
@@ -1666,8 +1667,8 @@ function collectNestedVarGlobals(L, sf, stmt, tag) {
    * the default's global by it makes every importer resolve to the same
    * storage through the ordinary globalOf path. Null for modules without
    * a default export (or non-module files). */
-export function defaultExportSymbolOf(L, sf) {
-    const moduleSym = L.checker.getSymbolAtLocation(sf);
+export function defaultExportSymbolOf(lowerer, sf) {
+    const moduleSym = lowerer.checker.getSymbolAtLocation(sf);
     return moduleSym?.getExports().get(ts.InternalSymbolName.Default) ?? null;
 }
 /** The declaration symbol of a top-level function/class declaration,
@@ -1677,14 +1678,14 @@ export function defaultExportSymbolOf(L, sf) {
    * symbol (the binder declares it there), so collection, reachability,
    * and body lowering all key that one identity — which is also what a
    * default import's alias chain resolves to. */
-export function declSymbolOf(L, decl) {
+export function declSymbolOf(lowerer, decl) {
     if (decl.name)
-        return L.checker.getSymbolAtLocation(decl.name);
+        return lowerer.checker.getSymbolAtLocation(decl.name);
     const isDefault = ts.canHaveModifiers(decl) &&
         ts.getModifiers(decl)?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) === true;
     if (!isDefault)
         return undefined;
-    const sym = defaultExportSymbolOf(L, decl.getSourceFile());
+    const sym = defaultExportSymbolOf(lowerer, decl.getSourceFile());
     return sym ?? undefined;
 }
 /** `export default <expr>` in a module's init body: the first (and only)
@@ -1700,11 +1701,11 @@ export function declSymbolOf(L, decl) {
    * registration (collection reported the blocker) re-lowers the
    * expression so the expression's OWN diagnostic wins when it has one,
    * then poisons. */
-export function lowerDefaultExport(L, stmt) {
-    const symbol = defaultExportSymbolOf(L, stmt.getSourceFile());
-    if (symbol && symbol.flags & ts.SymbolFlags.Alias && !L.globalsBySymbol.has(symbol))
+export function lowerDefaultExport(lowerer, stmt) {
+    const symbol = defaultExportSymbolOf(lowerer, stmt.getSourceFile());
+    if (symbol && symbol.flags & ts.SymbolFlags.Alias && !lowerer.globalsBySymbol.has(symbol))
         return null;
-    const g = symbol ? L.globalsBySymbol.get(symbol) : undefined;
+    const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
     if (!g) {
         // A provably-throwing decorated class expression registered no
         // storage (the registration pass skipped it): the statement IS the
@@ -1716,14 +1717,14 @@ export function lowerDefaultExport(L, stmt) {
             if (ts.isClassExpression(inner) && !isJsSourceFile(stmt.getSourceFile()) &&
                 inner.typeParameters === undefined &&
                 (decoratorNodesOf(inner).length > 0 || inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
-                guaranteedDecorationThrow(L, inner) !== null) {
-                return { kind: "exprStmt", expr: L.lowerExpr(stmt.expression), loc: locOf(stmt) };
+                guaranteedDecorationThrow(lowerer, inner) !== null) {
+                return { kind: "exprStmt", expr: lowerer.lowerExpr(stmt.expression), loc: locOf(stmt) };
             }
         }
-        L.lowerExpr(stmt.expression);
-        L.badType(stmt.expression, L.typeOf(stmt.expression));
+        lowerer.lowerExpr(stmt.expression);
+        lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
     }
-    const value = L.lowerExprExpecting(stmt.expression, g.type);
+    const value = lowerer.lowerExprExpecting(stmt.expression, g.type);
     return { kind: "assign", localId: g.id, value, loc: locOf(stmt) };
 }
 /** One file's top-level statements as its init function — RUN-ONCE like a
@@ -1740,16 +1741,16 @@ export function lowerDefaultExport(L, stmt) {
    * inline in the body. JSON-import bindings (pure data) load next; then
    * the body. Top-level var statements assign the pre-registered globals
    * instead of declaring locals. */
-export function lowerFileInit(L, sf, stmts, name) {
-    const isAsync = L.asyncInitFiles.has(sf);
+export function lowerFileInit(lowerer, sf, stmts, name) {
+    const isAsync = lowerer.asyncInitFiles.has(sf);
     const ctx = newFnCtx(false, null, null, VOID);
     ctx.isAsync = isAsync;
-    L.fnStack.push(ctx);
+    lowerer.fnStack.push(ctx);
     try {
         const loc0 = { file: sf.fileName, start: 0, end: 0 };
         const header = [];
         const asyncDeps = [];
-        const guardId = L.moduleGuardOf.get(sf);
+        const guardId = lowerer.moduleGuardOf.get(sf);
         if (guardId !== undefined) {
             header.push({
                 kind: "if",
@@ -1768,8 +1769,8 @@ export function lowerFileInit(L, sf, stmts, name) {
                 loc: loc0,
             });
         }
-        for (const { stmt, dep } of orderedImportsOf(L.program, sf)) {
-            const npm = L.npmInitActions.get(sf)?.get(stmt);
+        for (const { stmt, dep } of orderedImportsOf(lowerer.program, sf)) {
+            const npm = lowerer.npmInitActions.get(sf)?.get(stmt);
             if (npm !== undefined && npm.length > 0) {
                 header.push(...npm);
             }
@@ -1778,12 +1779,12 @@ export function lowerFileInit(L, sf, stmts, name) {
                 // to the importing module): Node answers it from the module
                 // cache mid-evaluation — no re-evaluation, nothing to call (and
                 // the ENTRY has no run-once guard, so a self-call would recurse).
-                const depInit = L.initNameOf.get(dep);
+                const depInit = lowerer.initNameOf.get(dep);
                 if (depInit !== undefined) {
                     const loc = locOf(stmt);
-                    const depAsync = L.asyncInitFiles.has(dep);
+                    const depAsync = lowerer.asyncInitFiles.has(dep);
                     if (depAsync && !isAsync) {
-                        L.unsupported("SC1090", stmt, `loading '${dep.fileName}' from a CommonJS module ` +
+                        lowerer.unsupported("SC1090", stmt, `loading '${dep.fileName}' from a CommonJS module ` +
                             "(the required ES-module graph uses top-level await; use import() instead)");
                     }
                     const call = {
@@ -1798,10 +1799,10 @@ export function lowerFileInit(L, sf, stmts, name) {
                         // any of them. ECMAScript's module evaluator continues into
                         // later sibling dependencies while an earlier one is
                         // suspended; the importer body waits for all of them.
-                        const p = L.declareHiddenLocal("%depInit", { kind: "promise", inner: VOID });
+                        const p = lowerer.declareHiddenLocal("%depInit", { kind: "promise", inner: VOID });
                         header.push({ kind: "varDecl", localId: p.id, init: call, loc });
-                        const sfCycle = L.asyncCycleRepresentativeOf.get(sf);
-                        const depCycle = L.asyncCycleRepresentativeOf.get(dep);
+                        const sfCycle = lowerer.asyncCycleRepresentativeOf.get(sf);
+                        const depCycle = lowerer.asyncCycleRepresentativeOf.get(dep);
                         const cycleInternal = sfCycle !== undefined && sfCycle === depCycle;
                         // An importer outside the requested member's SCC waits for
                         // the SCC's RUNTIME root, not merely that member's promise.
@@ -1812,7 +1813,7 @@ export function lowerFileInit(L, sf, stmts, name) {
                         // keep the member promise: their guard-hit completion is what
                         // breaks recursive evaluation without an await hop.
                         const completionId = !cycleInternal && depCycle !== undefined
-                            ? L.asyncCyclePromiseOf.get(dep)
+                            ? lowerer.asyncCyclePromiseOf.get(dep)
                             : p.id;
                         asyncDeps.push({
                             completionId,
@@ -1877,20 +1878,20 @@ export function lowerFileInit(L, sf, stmts, name) {
         // a function called above the declaration reads `undefined`, exactly
         // Node); checked-dynamic var globals hold the dyn undefined the same
         // way. After the guard: a cache-hit revisit must not reset them.
-        for (const g of L.varGlobalEntryInits.get(sf) ?? []) {
-            const wrapped = g.type.kind === "dyn" ? dynUndefinedExpr(loc0) : L.unassignedSlotInit(g.type, loc0);
+        for (const g of lowerer.varGlobalEntryInits.get(sf) ?? []) {
+            const wrapped = g.type.kind === "dyn" ? dynUndefinedExpr(loc0) : lowerer.unassignedSlotInit(g.type, loc0);
             if (wrapped) {
                 header.push({ kind: "assign", localId: g.id, value: wrapped, loc: loc0 });
             }
         }
-        const prelude = L.jsonInitActions.get(sf) ?? [];
+        const prelude = lowerer.jsonInitActions.get(sf) ?? [];
         // Class STATIC readonly fields, static BLOCKS, and class DECORATORS
         // run at their class statement's source position (splitFiles hoisted
         // the declarations out of `stmts`, so the statements merge back in
         // by position) — exactly when JS evaluates decorators, static
         // initializers, and blocks, so code reading an earlier module
         // binding sees its assigned value.
-        const statics = [...L.classes.values()]
+        const statics = [...lowerer.classes.values()]
             .filter((c) => 
         // Class DECLARATIONS only: expression classes run their static
         // inits through pendingClassExprInits (below) at the statement
@@ -1906,7 +1907,7 @@ export function lowerFileInit(L, sf, stmts, name) {
         // demand order (a nested mixin's base instantiates first, a
         // heritage base before its derived class), so the stable sort keeps
         // JS's evaluation order at equal positions.
-        for (const c of L.classes.values()) {
+        for (const c of lowerer.classes.values()) {
             const ms = c.mixinInstance?.statics;
             if (ms && ms.sf === sf)
                 statics.push({ pos: ms.pos, info: c });
@@ -1921,17 +1922,17 @@ export function lowerFileInit(L, sf, stmts, name) {
             // declarations never share a kept statement's start, so `<=`
             // changes nothing for them.
             while (at < statics.length && statics[at].pos <= stmt.getStart()) {
-                body.push(...L.lowerStaticFieldInits(statics[at].info));
+                body.push(...lowerer.lowerStaticFieldInits(statics[at].info));
                 at++;
             }
-            const stmtIr = L.lowerStmts([stmt]);
+            const stmtIr = lowerer.lowerStmts([stmt]);
             // Class EXPRESSIONS inside this statement queued their static
             // inits while it lowered: they land immediately before it — JS's
             // order for the supported whole-initializer positions.
-            body.push(...L.pendingClassExprInits.splice(0), ...stmtIr);
+            body.push(...lowerer.pendingClassExprInits.splice(0), ...stmtIr);
         }
         while (at < statics.length) {
-            body.push(...L.lowerStaticFieldInits(statics[at].info));
+            body.push(...lowerer.lowerStaticFieldInits(statics[at].info));
             at++;
         }
         const loc = { file: sf.fileName, start: 0, end: 0 };
@@ -1939,18 +1940,18 @@ export function lowerFileInit(L, sf, stmts, name) {
             name,
             params: [],
             returnType: VOID,
-            locals: L.ctx.locals,
+            locals: lowerer.ctx.locals,
             body,
             ...(isAsync ? { async: true } : {}),
-            ...(isAsync ? { asyncCacheGlobal: L.modulePromiseOf.get(sf) } : {}),
-            ...(L.asyncCyclePromiseOf.has(sf)
-                ? { asyncCycleCacheGlobal: L.asyncCyclePromiseOf.get(sf) }
+            ...(isAsync ? { asyncCacheGlobal: lowerer.modulePromiseOf.get(sf) } : {}),
+            ...(lowerer.asyncCyclePromiseOf.has(sf)
+                ? { asyncCycleCacheGlobal: lowerer.asyncCyclePromiseOf.get(sf) }
                 : {}),
             loc,
         };
     }
     finally {
-        L.fnStack.pop();
+        lowerer.fnStack.pop();
     }
 }
 /** %main is just the entry's %init call: Node's whole module evaluation
@@ -1959,10 +1960,10 @@ export function lowerFileInit(L, sf, stmts, name) {
    * nesting), CommonJS require statements call dependency inits inline in
    * their bodies, and the run-once guards turn every revisit (diamonds,
    * re-imports, re-requires) into a cache hit. */
-export function buildMain(L) {
-    const loc = { file: L.entry.fileName, start: 0, end: 0 };
-    const entryInit = L.initNameOf.get(L.entry);
-    const isAsync = L.asyncInitFiles.has(L.entry);
+export function buildMain(lowerer) {
+    const loc = { file: lowerer.entry.fileName, start: 0, end: 0 };
+    const entryInit = lowerer.initNameOf.get(lowerer.entry);
+    const isAsync = lowerer.asyncInitFiles.has(lowerer.entry);
     const initCall = entryInit !== undefined
         ? {
             kind: "call",
@@ -1990,15 +1991,15 @@ export function buildMain(L) {
     // never runs. The init still lowers — the program must otherwise
     // compile, exactly like Node parses every module before its
     // fetch/instantiate phases refuse the graph.
-    if (L.startupCrash !== null) {
-        const crashLoc = L.startupCrash.loc;
+    if (lowerer.startupCrash !== null) {
+        const crashLoc = lowerer.startupCrash.loc;
         body.unshift({
             kind: "throw",
             value: {
                 kind: "libCall",
                 fn: "error.new",
-                args: [{ kind: "strLit", value: L.startupCrash.message, type: STRING, loc: crashLoc }],
-                type: { kind: "object", className: L.startupCrash.className },
+                args: [{ kind: "strLit", value: lowerer.startupCrash.message, type: STRING, loc: crashLoc }],
+                type: { kind: "object", className: lowerer.startupCrash.className },
                 loc: crashLoc,
             },
             loc: crashLoc,