@scriptc/compiler 0.0.35 → 0.1.1

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

@@ -1,10 +1,11 @@
+import { InternalCompilerError } from "../../errors.js";
 /* Island-boundary lowering: jsval marshaling into the island (jsvalIn and
  * its boundary fences), island-expression detection, the island method-call
  * surface (Math and number/string methods under --dynamic), and the npm
  * package boundary fences for node_modules-declared symbols. */
 import * as ts from "../ts7/adapter.js";
-import { BOOL, BYTES_U8, DYN, F64, JSVAL, MAX_ISLAND_CALLBACK_ARITY, STRING, VOID, canConvertToDyn, canMarshalTypedFuncIntoIsland, islandPromisePayloadTag, isUnitType } from "../../ir/nodes.js";
-import { ISLAND_SURFACE, STATIC_MATH_FNS, boundaryIntoIslandMsg } from "./surfaces.js";
+import { BOOL, BYTES_U8, DYN, F64, JSVAL, MAX_ISLAND_CALLBACK_ARITY, STRING, VOID, canConvertToDyn, canMarshalTypedFuncIntoIsland, islandPromisePayloadTag, isUnitType } from "../../ir/ir.js";
+import { ISLAND_SURFACE, STATIC_MATH_FNS, STATIC_MATH_PROPS, boundaryIntoIslandMsg } from "./surfaces.js";
 import { requiresDynamicApiDiag, requiresDynamicPackageDiag } from "../../diagnostics/diagnostic.js";
 import { isCjsJsFile, isJsSourceFile, locOf, npmPackageNameOf } from "../program.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral, pureReemittable } from "./lower-exprs.js";
@@ -20,18 +21,18 @@ import { NODE24_FETCH_COMPAT_PROFILE, STATIC_HEADERS_CALLS, STATIC_READABLE_STRE
    * re-reporting the declared type. The one exclusion is promise-mapped
    * declared types: a package promise held as a handle keeps its existing
    * checker-driven dispatch (the await/.catch bridge lowerings own it). */
-export function isIslandExpr(L, node) {
-    const mapped = L.mapTypeOf(L.typeOf(node));
+export function isIslandExpr(lowerer, node) {
+    const mapped = lowerer.mapTypeOf(lowerer.typeOf(node));
     if (mapped?.kind === "jsval")
         return true;
     if (mapped?.kind !== "promise" && ts.isIdentifier(node)) {
-        const local = L.peekLocal(node);
+        const local = lowerer.peekLocal(node);
         if (local?.type.kind === "jsval")
             return true;
         // File-scope handle bindings (a module global slotted jsval by the
         // island-pattern or unchecked-overload rules) take the same rule as
         // locals: the handle is the value's only story.
-        if (!local && L.globalOf(node)?.type.kind === "jsval")
+        if (!local && lowerer.globalOf(node)?.type.kind === "jsval")
             return true;
     }
     return false;
@@ -47,44 +48,25 @@ export function isIslandExpr(L, node) {
  * invoked — building the value compiles; only a call through the
  * island stops the run. Null (caller rethrows) outside the JS deferral
  * gate: TypeScript sources, probe mode, ICEs. */
-export function islandFuncValueFence(L, err, diagsBefore, node) {
-    if (!(err instanceof PoisonError) ||
-        !isJsSourceFile(node.getSourceFile()) ||
-        L.diagSink !== null ||
-        L.diags.length <= diagsBefore ||
-        L.diags.slice(diagsBefore).some((d) => d.code === "SC9001")) {
-        return null;
-    }
-    const captured = L.diags.splice(diagsBefore);
-    L.runtimeFences.push(...captured);
-    const first = captured[0];
-    const pos = ts.getLineAndCharacterOfPosition(L.program.getSourceFile(first.loc.file) ?? node.getSourceFile(), first.loc.start);
-    const loc = locOf(node);
-    const fnName = `%fn${L.lambdaCounter++}_islfence`;
-    L.liftedFns.push({
-        name: fnName,
-        params: [],
+export function islandFuncValueFence(lowerer, err, diagsBefore, node) {
+    if (!(err instanceof PoisonError) || !isJsSourceFile(node.getSourceFile()))
+        return null;
+    const fence = lowerer.deferToRuntimeFence(diagsBefore, node, {
+        kind: "closure",
+        name: () => `%fn${lowerer.lambdaCounter++}_islfence`,
         returnType: VOID,
-        locals: [],
-        captures: [],
-        body: [
-            {
-                kind: "runtimeFence",
-                code: first.code,
-                message: `${first.message} [${first.code} at ${first.loc.file}:${pos.line + 1}]`,
-                loc,
-            },
-        ],
-        loc,
+        type: { kind: "func", params: [], ret: VOID },
     });
+    if (!fence)
+        return null;
     return {
         kind: "jsMarshal",
-        value: { kind: "closure", fnName, captures: [], type: { kind: "func", params: [], ret: VOID }, loc },
+        value: fence,
         type: JSVAL,
-        loc,
+        loc: fence.loc,
     };
 }
-export function jsvalIn(L, e, node) {
+export function jsvalIn(lowerer, e, node) {
     if (e.type.kind === "jsval")
         return e;
     // Bare unit literals (`undefined` / `null` in an 'any' slot): the
@@ -110,10 +92,10 @@ export function jsvalIn(L, e, node) {
     // Anything outside both shapes gets the specific fix, not the generic
     // boundary recitation.
     if (e.type.kind === "func" &&
-        !canMarshalTypedFuncIntoIsland(e.type, (id) => L.shapes.get(id), (id) => L.unions.get(id))) {
-        const diagsBefore = L.diags.length;
+        !canMarshalTypedFuncIntoIsland(e.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+        const diagsBefore = lowerer.diags.length;
         try {
-            L.unsupported("SC1090", node, `functions with this signature crossing into dynamically-executed code ` +
+            lowerer.unsupported("SC1090", node, `functions with this signature crossing into dynamically-executed code ` +
                 `(a callback passed to a package/'any' API may take 'any' parameters — ` +
                 `leave them unannotated so contextual typing keeps them 'any' — or parameters ` +
                 `convertible at the boundary (number, string, boolean, JSON-safe ` +
@@ -128,7 +110,7 @@ export function jsvalIn(L, e, node) {
             // diagnostic when INVOKED (the withPlugins aggregation shape —
             // wrappers built at module init around functions the smoke path
             // never calls). TypeScript and probe mode keep the poison.
-            const fence = islandFuncValueFence(L, err, diagsBefore, node);
+            const fence = islandFuncValueFence(lowerer, err, diagsBefore, node);
             if (fence)
                 return fence;
             throw err;
@@ -143,7 +125,7 @@ export function jsvalIn(L, e, node) {
     if (e.type.kind === "promise" && islandPromisePayloadTag(e.type.inner) !== null) {
         return { kind: "jsMarshal", value: e, type: JSVAL, loc: e.loc };
     }
-    if (e.type.kind !== "func" && !L.boundarySafe(e.type)) {
+    if (e.type.kind !== "func" && !lowerer.boundarySafe(e.type)) {
         // A RegExp crossing INTO the island (`z.string().regex(/^a+$/)` —
         // the validation-pattern argument): the engine compiles its own
         // from source+flags. A fresh engine RegExp per marshal — identity
@@ -158,9 +140,9 @@ export function jsvalIn(L, e, node) {
         // jsval-BEARING composites (an `any[]` value, a record holding one)
         // have no JSON marshal but an honest per-field/per-element island
         // construction — the same lift the implicit coercion path uses.
-        if (L.jsvalLiftable(e.type))
-            return L.jsvalLiftExpr(e, e.loc);
-        L.unsupported("SC1090", node, boundaryIntoIslandMsg(L.fmt(e.type)));
+        if (lowerer.jsvalLiftable(e.type))
+            return lowerer.jsvalLiftExpr(e, e.loc);
+        lowerer.unsupported("SC1090", node, boundaryIntoIslandMsg(lowerer.fmt(e.type)));
     }
     return { kind: "jsMarshal", value: e, type: JSVAL, loc: e.loc };
 }
@@ -204,26 +186,26 @@ export function islandRegexpOf(e) {
    * proceeds to engine ops; without it the use site is a per-site SC2012
    * (poison-recovered, so every site in the program reports — and the
    * coverage report groups them under "runs with --dynamic"). */
-export function requireDynamicApi(L, feature, node) {
-    if (L.dynamic)
+export function requireDynamicApi(lowerer, feature, node) {
+    if (lowerer.dynamic)
         return;
-    L.pushDiag(requiresDynamicApiDiag(feature, locOf(node)));
+    lowerer.pushDiag(requiresDynamicApiDiag(feature, locOf(node)));
     throw new PoisonError();
 }
 /** Resolves an identifier to an island-backed ambient GLOBAL function
    * (parseFloat, isFinite). Provenance, not name: the
    * symbol's declaration must live in the ambient file, so a user function
    * named `parseFloat` never matches. */
-export function islandGlobalFnOf(L, ident) {
+export function islandGlobalFnOf(lowerer, ident) {
     const entry = own(ISLAND_SURFACE.globals, ident.text);
     if (!entry)
         return null;
-    const symbol = L.resolveValueSymbol(ident);
-    if (!symbol || !L.isStdlibSymbol(symbol))
+    const symbol = lowerer.resolveValueSymbol(ident);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
     return entry;
 }
-function requestInitLiteralKey(L, prop) {
+function requestInitLiteralKey(lowerer, prop) {
     if (!ts.isPropertyAssignment(prop) &&
         !ts.isShorthandPropertyAssignment(prop) &&
         !ts.isMethodDeclaration(prop)) {
@@ -235,7 +217,7 @@ function requestInitLiteralKey(L, prop) {
     if (ts.isNumericLiteral(name))
         return String(Number(name.text));
     if (ts.isComputedPropertyName(name))
-        return foldedStringKeyOf(L, name.expression);
+        return foldedStringKeyOf(lowerer, name.expression);
     return null;
 }
 /** Fence declared RequestInit members outside the selected compiler tier.
@@ -253,21 +235,21 @@ function requestInitValueExpr(expr) {
     }
     return current;
 }
-function requestInitStaticBoolean(L, value) {
+function requestInitStaticBoolean(lowerer, value) {
     const expr = requestInitValueExpr(value);
     if (expr.kind === ts.SyntaxKind.TrueKeyword)
         return true;
     if (expr.kind === ts.SyntaxKind.FalseKeyword)
         return false;
-    const text = L.checker.typeToString(L.typeOf(expr));
+    const text = lowerer.checker.typeToString(lowerer.typeOf(expr));
     return text === "true" ? true : text === "false" ? false : null;
 }
 /** Symbols whose object value is mutated through a property write. A const
  * binding keeps the binding stable, not the object: following its initializer
  * after `init.cache = undefined` would diagnose the stale literal instead of
  * the value fetch actually observes. Built lazily and diagnostic-free. */
-function requestInitPropMutatedSymbols(L) {
-    const holder = L;
+function requestInitPropMutatedSymbols(lowerer) {
+    const holder = lowerer;
     if (holder.requestInitPropMutatedSyms) {
         return holder.requestInitPropMutatedSyms;
     }
@@ -281,7 +263,7 @@ function requestInitPropMutatedSymbols(L) {
         if (!ts.isIdentifier(base))
             return;
         try {
-            const symbol = L.resolveValueSymbol(base);
+            const symbol = lowerer.resolveValueSymbol(base);
             if (symbol)
                 symbols.add(symbol);
         }
@@ -289,7 +271,7 @@ function requestInitPropMutatedSymbols(L) {
             /* not a traceable RequestInit candidate */
         }
     };
-    for (const source of L.program.getSourceFiles()) {
+    for (const source of lowerer.program.getSourceFiles()) {
         if (source.isDeclarationFile)
             continue;
         const walk = (node) => {
@@ -318,39 +300,38 @@ function requestInitPropMutatedSymbols(L) {
     holder.requestInitPropMutatedSyms = symbols;
     return symbols;
 }
-function requestInitConstBacked(L, value, seen) {
+function requestInitConstBacked(lowerer, value, seen) {
     const expr = requestInitValueExpr(value);
     if (ts.isObjectLiteralExpression(expr))
         return true;
     if (ts.isConditionalExpression(expr)) {
-        const selected = requestInitStaticBoolean(L, expr.condition);
+        const selected = requestInitStaticBoolean(lowerer, expr.condition);
         if (selected !== null) {
-            return requestInitConstBacked(L, selected ? expr.whenTrue : expr.whenFalse, new Set(seen));
+            return requestInitConstBacked(lowerer, selected ? expr.whenTrue : expr.whenFalse, new Set(seen));
         }
-        return requestInitConstBacked(L, expr.whenTrue, new Set(seen)) &&
-            requestInitConstBacked(L, expr.whenFalse, new Set(seen));
+        return requestInitConstBacked(lowerer, expr.whenTrue, new Set(seen)) &&
+            requestInitConstBacked(lowerer, expr.whenFalse, new Set(seen));
     }
     if (!ts.isIdentifier(expr))
         return false;
-    const symbol = L.resolveValueSymbol(expr);
+    const symbol = lowerer.resolveValueSymbol(expr);
     if (!symbol || seen.has(symbol))
         return false;
-    if (requestInitPropMutatedSymbols(L).has(symbol))
+    if (requestInitPropMutatedSymbols(lowerer).has(symbol))
         return false;
     seen.add(symbol);
-    const declarations = L.checker.declarationsOf(symbol).filter((declaration) => ts.isVariableDeclaration(declaration) &&
+    const declarations = lowerer.checker.declarationsOf(symbol).filter((declaration) => ts.isVariableDeclaration(declaration) &&
         declaration.initializer !== undefined &&
         ts.isVariableDeclarationList(declaration.parent) &&
         (declaration.parent.flags & ts.NodeFlags.Const) !== 0);
-    return declarations.length > 0 && declarations.every((declaration) => requestInitConstBacked(L, declaration.initializer, new Set(seen)));
+    return declarations.length > 0 && declarations.every((declaration) => requestInitConstBacked(lowerer, declaration.initializer, new Set(seen)));
 }
-/** Visit the source values of one property on a const-backed object. The
- * checker's property symbol can come from an annotation (a PropertySignature)
- * rather than the object literal that supplies the runtime value, so source
- * tracing has to follow the receiver initializer by key as well. */
-function visitRequestInitConstPropertyValues(L, value, key, seen, visit) {
+/** Visit the values selected by one key or index on a const-backed object or
+ * array. Property symbols can come from annotations rather than the literal
+ * supplying the runtime value, so tracing follows receiver initializers. */
+function visitRequestInitConstSelectedValues(lowerer, value, selector, seen, visit) {
     const expr = requestInitValueExpr(value);
-    if (ts.isObjectLiteralExpression(expr)) {
+    if (selector.kind === "property" && ts.isObjectLiteralExpression(expr)) {
         // Last contributor wins. A definite later property (including one from
         // a statically traced spread) hides earlier values exactly as it does at
         // runtime; a conditional/missing spread keeps the earlier contributor
@@ -358,12 +339,12 @@ function visitRequestInitConstPropertyValues(L, value, key, seen, visit) {
         for (let i = expr.properties.length - 1; i >= 0; i--) {
             const property = expr.properties[i];
             if (ts.isSpreadAssignment(property)) {
-                const defines = visitRequestInitConstPropertyValues(L, property.expression, key, new Set(seen), visit);
+                const defines = visitRequestInitConstSelectedValues(lowerer, property.expression, selector, new Set(seen), visit);
                 if (defines)
                     return true;
                 continue;
             }
-            if (requestInitLiteralKey(L, property) !== key)
+            if (requestInitLiteralKey(lowerer, property) !== selector.key)
                 continue;
             if (ts.isPropertyAssignment(property)) {
                 visit(property.initializer);
@@ -376,58 +357,8 @@ function visitRequestInitConstPropertyValues(L, value, key, seen, visit) {
         }
         return false;
     }
-    if (ts.isConditionalExpression(expr)) {
-        const selected = requestInitStaticBoolean(L, expr.condition);
-        if (selected !== null) {
-            return visitRequestInitConstPropertyValues(L, selected ? expr.whenTrue : expr.whenFalse, key, seen, visit);
-        }
-        const whenTrue = visitRequestInitConstPropertyValues(L, expr.whenTrue, key, new Set(seen), visit);
-        const whenFalse = visitRequestInitConstPropertyValues(L, expr.whenFalse, key, new Set(seen), visit);
-        return whenTrue && whenFalse;
-    }
-    if (ts.isPropertyAccessExpression(expr) || ts.isElementAccessExpression(expr)) {
-        const member = ts.isPropertyAccessExpression(expr)
-            ? expr.name.text
-            : foldedStringKeyOf(L, expr.argumentExpression);
-        if (member === null)
-            return false;
-        const nested = [];
-        const receiverDefines = visitRequestInitConstPropertyValues(L, expr.expression, member, new Set(seen), (value) => nested.push(value));
-        let nestedDefines = nested.length > 0;
-        for (const value of nested) {
-            if (!visitRequestInitConstPropertyValues(L, value, key, new Set(seen), visit)) {
-                nestedDefines = false;
-            }
-        }
-        return receiverDefines && nestedDefines;
-    }
-    if (!ts.isIdentifier(expr))
-        return false;
-    const symbol = L.resolveValueSymbol(expr);
-    if (!symbol || seen.has(symbol))
-        return false;
-    if (requestInitPropMutatedSymbols(L).has(symbol))
-        return false;
-    seen.add(symbol);
-    let sawDeclaration = false;
-    let defines = true;
-    for (const declaration of L.checker.declarationsOf(symbol)) {
-        if (ts.isVariableDeclaration(declaration) &&
-            declaration.initializer !== undefined &&
-            ts.isVariableDeclarationList(declaration.parent) &&
-            (declaration.parent.flags & ts.NodeFlags.Const) !== 0) {
-            sawDeclaration = true;
-            if (!visitRequestInitConstPropertyValues(L, declaration.initializer, key, new Set(seen), visit)) {
-                defines = false;
-            }
-        }
-    }
-    return sawDeclaration && defines;
-}
-function visitRequestInitConstIndexValues(L, value, index, seen, visit) {
-    const expr = requestInitValueExpr(value);
-    if (ts.isArrayLiteralExpression(expr)) {
-        const element = expr.elements[index];
+    if (selector.kind === "index" && ts.isArrayLiteralExpression(expr)) {
+        const element = expr.elements[selector.index];
         if (element === undefined ||
             ts.isOmittedExpression(element) ||
             ts.isSpreadElement(element)) {
@@ -437,25 +368,25 @@ function visitRequestInitConstIndexValues(L, value, index, seen, visit) {
         return true;
     }
     if (ts.isConditionalExpression(expr)) {
-        const selected = requestInitStaticBoolean(L, expr.condition);
+        const selected = requestInitStaticBoolean(lowerer, expr.condition);
         if (selected !== null) {
-            return visitRequestInitConstIndexValues(L, selected ? expr.whenTrue : expr.whenFalse, index, seen, visit);
+            return visitRequestInitConstSelectedValues(lowerer, selected ? expr.whenTrue : expr.whenFalse, selector, seen, visit);
         }
-        const whenTrue = visitRequestInitConstIndexValues(L, expr.whenTrue, index, new Set(seen), visit);
-        const whenFalse = visitRequestInitConstIndexValues(L, expr.whenFalse, index, new Set(seen), visit);
+        const whenTrue = visitRequestInitConstSelectedValues(lowerer, expr.whenTrue, selector, new Set(seen), visit);
+        const whenFalse = visitRequestInitConstSelectedValues(lowerer, expr.whenFalse, selector, new Set(seen), visit);
         return whenTrue && whenFalse;
     }
     if (ts.isPropertyAccessExpression(expr) || ts.isElementAccessExpression(expr)) {
         const member = ts.isPropertyAccessExpression(expr)
             ? expr.name.text
-            : foldedStringKeyOf(L, expr.argumentExpression);
+            : foldedStringKeyOf(lowerer, expr.argumentExpression);
         if (member === null)
             return false;
         const nested = [];
-        const receiverDefines = visitRequestInitConstPropertyValues(L, expr.expression, member, new Set(seen), (value) => nested.push(value));
+        const receiverDefines = visitRequestInitConstSelectedValues(lowerer, expr.expression, { kind: "property", key: member }, new Set(seen), (value) => nested.push(value));
         let nestedDefines = nested.length > 0;
         for (const value of nested) {
-            if (!visitRequestInitConstIndexValues(L, value, index, new Set(seen), visit)) {
+            if (!visitRequestInitConstSelectedValues(lowerer, value, selector, new Set(seen), visit)) {
                 nestedDefines = false;
             }
         }
@@ -463,28 +394,28 @@ function visitRequestInitConstIndexValues(L, value, index, seen, visit) {
     }
     if (!ts.isIdentifier(expr))
         return false;
-    const symbol = L.resolveValueSymbol(expr);
+    const symbol = lowerer.resolveValueSymbol(expr);
     if (!symbol || seen.has(symbol))
         return false;
-    if (requestInitPropMutatedSymbols(L).has(symbol))
+    if (requestInitPropMutatedSymbols(lowerer).has(symbol))
         return false;
     seen.add(symbol);
     let sawDeclaration = false;
     let defines = true;
-    for (const declaration of L.checker.declarationsOf(symbol)) {
+    for (const declaration of lowerer.checker.declarationsOf(symbol)) {
         if (ts.isVariableDeclaration(declaration) &&
             declaration.initializer !== undefined &&
             ts.isVariableDeclarationList(declaration.parent) &&
             (declaration.parent.flags & ts.NodeFlags.Const) !== 0) {
             sawDeclaration = true;
-            if (!visitRequestInitConstIndexValues(L, declaration.initializer, index, new Set(seen), visit)) {
+            if (!visitRequestInitConstSelectedValues(lowerer, declaration.initializer, selector, new Set(seen), visit)) {
                 defines = false;
             }
         }
     }
     return sawDeclaration && defines;
 }
-function requestInitConstBindingSource(L, declaration) {
+function requestInitConstBindingSource(lowerer, declaration) {
     const selectors = [];
     let current = declaration;
     while (true) {
@@ -492,7 +423,7 @@ function requestInitConstBindingSource(L, declaration) {
         if (ts.isObjectBindingPattern(pattern)) {
             if (current.dotDotDotToken)
                 return null;
-            const key = fetchObjectBindingMemberName(L, current);
+            const key = fetchObjectBindingMemberName(lowerer, current);
             if (key === null)
                 return null;
             selectors.unshift({ kind: "property", key });
@@ -522,7 +453,7 @@ function requestInitConstBindingSource(L, declaration) {
         return { initializer: owner.initializer, selectors };
     }
 }
-function visitRequestInitConstBindingValues(L, value, selectors, seen, visit) {
+function visitRequestInitConstBindingValues(lowerer, value, selectors, seen, visit) {
     const selector = selectors[0];
     if (selector === undefined) {
         visit(value);
@@ -530,59 +461,57 @@ function visitRequestInitConstBindingValues(L, value, selectors, seen, visit) {
     }
     let nestedDefines = true;
     const visitNested = (nested) => {
-        if (!visitRequestInitConstBindingValues(L, nested, selectors.slice(1), new Set(seen), visit)) {
+        if (!visitRequestInitConstBindingValues(lowerer, nested, selectors.slice(1), new Set(seen), visit)) {
             nestedDefines = false;
         }
     };
-    const defines = selector.kind === "property"
-        ? visitRequestInitConstPropertyValues(L, value, selector.key, seen, visitNested)
-        : visitRequestInitConstIndexValues(L, value, selector.index, seen, visitNested);
+    const defines = visitRequestInitConstSelectedValues(lowerer, value, selector, seen, visitNested);
     return defines && nestedDefines;
 }
-function fenceRequestInitProperty(L, access, seen) {
+function fenceRequestInitProperty(lowerer, access, seen) {
     const key = ts.isPropertyAccessExpression(access)
         ? access.name.text
-        : foldedStringKeyOf(L, access.argumentExpression);
+        : foldedStringKeyOf(lowerer, access.argumentExpression);
     if (key === null)
         return;
-    visitRequestInitConstPropertyValues(L, access.expression, key, new Set(), (value) => fenceRequestInitValueInner(L, value, seen));
-    if (!requestInitConstBacked(L, access.expression, new Set()))
+    visitRequestInitConstSelectedValues(lowerer, access.expression, { kind: "property", key }, new Set(), (value) => fenceRequestInitValueInner(lowerer, value, seen));
+    if (!requestInitConstBacked(lowerer, access.expression, new Set()))
         return;
     const symbol = ts.isPropertyAccessExpression(access)
-        ? L.checker.getSymbolAtLocation(access.name)
-        : L.checker.getPropertyOfType(L.typeOf(access.expression), key);
+        ? lowerer.checker.getSymbolAtLocation(access.name)
+        : lowerer.checker.getPropertyOfType(lowerer.typeOf(access.expression), key);
     if (!symbol || seen.has(symbol))
         return;
     seen.add(symbol);
-    for (const declaration of L.checker.declarationsOf(symbol)) {
+    for (const declaration of lowerer.checker.declarationsOf(symbol)) {
         if (ts.isPropertyAssignment(declaration)) {
-            fenceRequestInitValueInner(L, declaration.initializer, seen);
+            fenceRequestInitValueInner(lowerer, declaration.initializer, seen);
         }
         else if (ts.isShorthandPropertyAssignment(declaration) &&
             ts.isIdentifier(declaration.name)) {
-            fenceRequestInitValueInner(L, declaration.name, seen);
+            fenceRequestInitValueInner(lowerer, declaration.name, seen);
         }
     }
 }
-function fenceRequestInitObject(L, init, seen) {
-    const contextual = L.checker.getContextualType(init);
+function fenceRequestInitObject(lowerer, init, seen) {
+    const contextual = lowerer.checker.getContextualType(init);
     const contextualArms = contextual?.isUnionType() ? ts.constituentTypes(contextual) : contextual ? [contextual] : [];
     const rows = NODE24_FETCH_COMPAT_PROFILE.inventory.entries.filter((entry) => entry.owner === "RequestInit" && entry.placement === "dictionary");
     const shadowed = new Set();
     const fence = (row, value, blame) => {
-        if (L.dynamic ? row.status !== "unsupported" : row.status === "static")
+        if (lowerer.dynamic ? row.status !== "unsupported" : row.status === "static")
             return;
         if (value !== null) {
-            const type = L.typeOf(requestInitValueExpr(value));
+            const type = lowerer.typeOf(requestInitValueExpr(value));
             if (ts.isVoidExpression(requestInitValueExpr(value)) ||
                 (type.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) !== 0) {
                 return;
             }
         }
         const sym = contextualArms
-            .map((arm) => L.checker.getPropertyOfType(arm, row.member))
+            .map((arm) => lowerer.checker.getPropertyOfType(arm, row.member))
             .find((member) => member !== undefined);
-        L.noLowering(`RequestInit option '${row.member}'${L.dynamic ? "" : " in a static build"}`, blame, row.reason ??
+        lowerer.noLowering(`RequestInit option '${row.member}'${lowerer.dynamic ? "" : " in a static build"}`, blame, row.reason ??
             "the native static RequestInit surface is method, headers, body, duplex, redirect, and signal", sym);
     };
     // Object spread is last-write-wins. Walk from the end and trace only the
@@ -595,13 +524,13 @@ function fenceRequestInitObject(L, init, seen) {
             for (const row of rows) {
                 if (shadowed.has(row.member))
                     continue;
-                const defines = visitRequestInitConstPropertyValues(L, prop.expression, row.member, new Set(seen), (value) => fence(row, value, value));
+                const defines = visitRequestInitConstSelectedValues(lowerer, prop.expression, { kind: "property", key: row.member }, new Set(seen), (value) => fence(row, value, value));
                 if (defines)
                     shadowed.add(row.member);
             }
             continue;
         }
-        const key = requestInitLiteralKey(L, prop);
+        const key = requestInitLiteralKey(lowerer, prop);
         if (key === null || shadowed.has(key))
             continue;
         shadowed.add(key);
@@ -622,25 +551,25 @@ function fenceRequestInitObject(L, init, seen) {
  * members, so follow their initializers until the profile can make the
  * decision. Runtime-computed values keep both fetch runtimes' defensive
  * validation because there is no source member to diagnose. */
-function fenceRequestInitValueInner(L, value, seen) {
+function fenceRequestInitValueInner(lowerer, value, seen) {
     const expr = requestInitValueExpr(value);
     if (ts.isObjectLiteralExpression(expr)) {
-        fenceRequestInitObject(L, expr, seen);
+        fenceRequestInitObject(lowerer, expr, seen);
         return;
     }
     if (ts.isConditionalExpression(expr)) {
-        const selected = requestInitStaticBoolean(L, expr.condition);
+        const selected = requestInitStaticBoolean(lowerer, expr.condition);
         if (selected !== null) {
-            fenceRequestInitValueInner(L, selected ? expr.whenTrue : expr.whenFalse, seen);
+            fenceRequestInitValueInner(lowerer, selected ? expr.whenTrue : expr.whenFalse, seen);
         }
         else {
-            fenceRequestInitValueInner(L, expr.whenTrue, seen);
-            fenceRequestInitValueInner(L, expr.whenFalse, seen);
+            fenceRequestInitValueInner(lowerer, expr.whenTrue, seen);
+            fenceRequestInitValueInner(lowerer, expr.whenFalse, seen);
         }
         return;
     }
     if (ts.isPropertyAccessExpression(expr) || ts.isElementAccessExpression(expr)) {
-        fenceRequestInitProperty(L, expr, seen);
+        fenceRequestInitProperty(lowerer, expr, seen);
         return;
     }
     if (!ts.isIdentifier(expr))
@@ -649,17 +578,17 @@ function fenceRequestInitValueInner(L, value, seen) {
     // exported const whose initializer carries the dictionary members.
     // Chase the value alias so local and cross-module const plumbing share
     // the same source-profile fence.
-    const symbol = L.resolveValueSymbol(expr);
+    const symbol = lowerer.resolveValueSymbol(expr);
     if (!symbol || seen.has(symbol))
         return;
-    if (requestInitPropMutatedSymbols(L).has(symbol))
+    if (requestInitPropMutatedSymbols(lowerer).has(symbol))
         return;
     seen.add(symbol);
-    for (const declaration of L.checker.declarationsOf(symbol)) {
+    for (const declaration of lowerer.checker.declarationsOf(symbol)) {
         if (ts.isBindingElement(declaration)) {
-            const source = requestInitConstBindingSource(L, declaration);
+            const source = requestInitConstBindingSource(lowerer, declaration);
             if (source !== null) {
-                visitRequestInitConstBindingValues(L, source.initializer, source.selectors, new Set(seen), (bindingValue) => fenceRequestInitValueInner(L, bindingValue, new Set(seen)));
+                visitRequestInitConstBindingValues(lowerer, source.initializer, source.selectors, new Set(seen), (bindingValue) => fenceRequestInitValueInner(lowerer, bindingValue, new Set(seen)));
             }
             continue;
         }
@@ -669,11 +598,11 @@ function fenceRequestInitValueInner(L, value, seen) {
             (declaration.parent.flags & ts.NodeFlags.Const) === 0) {
             continue;
         }
-        fenceRequestInitValueInner(L, declaration.initializer, seen);
+        fenceRequestInitValueInner(lowerer, declaration.initializer, seen);
     }
 }
-function fenceRequestInitValue(L, value) {
-    fenceRequestInitValueInner(L, value, new Set());
+function fenceRequestInitValue(lowerer, value) {
+    fenceRequestInitValueInner(lowerer, value, new Set());
 }
 /** USER-code `fetch(url)` / `fetch(url, init)` — the ambient global
    * (provenance, not the name: a user's own `fetch` never matches).
@@ -697,41 +626,41 @@ function fenceRequestInitValue(L, value) {
    * the user's narrowing sites through the validated-exit machinery.
    * Null for anything that isn't THE ambient fetch, so lowerCall keeps
    * trying. */
-export function lowerFetchCall(L, call) {
+export function lowerFetchCall(lowerer, call) {
     const callee = call.expression;
     if (!ts.isIdentifier(callee) || callee.text !== "fetch")
         return null;
     if (call.questionDotToken)
         return null;
-    const symbol = L.resolveValueSymbol(callee);
-    if (!symbol || !L.isStdlibSymbol(symbol))
+    const symbol = lowerer.resolveValueSymbol(callee);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
     if (call.arguments.length < 1)
         return null;
     const loc = locOf(call);
     const initNode = call.arguments[1];
     if (initNode !== undefined)
-        fenceRequestInitValue(L, initNode);
-    if (!L.dynamic) {
+        fenceRequestInitValue(lowerer, initNode);
+    if (!lowerer.dynamic) {
         const inputNode = call.arguments[0];
-        const input = L.lowerExpr(inputNode);
+        const input = lowerer.lowerExpr(inputNode);
         let init;
         if (initNode === undefined) {
             init = dynUndefinedExpr(loc);
         }
         else if (ts.isObjectLiteralExpression(initNode)) {
-            init = lowerDynObjectLiteral(L, initNode);
+            init = lowerDynObjectLiteral(lowerer, initNode);
         }
         else {
-            init = L.lowerExprExpecting(initNode, DYN);
+            init = lowerer.lowerExprExpecting(initNode, DYN);
         }
         // Calling a WebIDL operation has two distinct phases: JavaScript
         // first evaluates every argument expression, then the callee converts
         // those values. In particular, evaluating RequestInit may mutate a
         // URL object passed as input; its href must not be snapshotted until
         // all argument expressions (including ignored surplus ones) ran.
-        const inputLocal = L.declareHiddenLocal("%fetchInput", input.type);
-        const initLocal = L.declareHiddenLocal("%fetchInit", init.type);
+        const inputLocal = lowerer.declareHiddenLocal("%fetchInput", input.type);
+        const initLocal = lowerer.declareHiddenLocal("%fetchInit", init.type);
         const inputRef = {
             kind: "varRef",
             localId: inputLocal.id,
@@ -750,11 +679,11 @@ export function lowerFetchCall(L, call) {
         ];
         for (const argument of call.arguments.slice(2)) {
             if (ts.isSpreadElement(argument)) {
-                L.noLowering("spread surplus arguments on static fetch()", argument, "pass surplus arguments without spread syntax");
+                lowerer.noLowering("spread surplus arguments on static fetch()", argument, "pass surplus arguments without spread syntax");
             }
             const discarded = ts.isVoidExpression(argument)
-                ? L.lowerExpr(argument.expression)
-                : L.lowerExpr(argument);
+                ? lowerer.lowerExpr(argument.expression)
+                : lowerer.lowerExpr(argument);
             stmts.push({ kind: "exprStmt", expr: discarded, loc: discarded.loc });
         }
         const url = input.type.kind === "url"
@@ -765,7 +694,7 @@ export function lowerFetchCall(L, call) {
                 type: STRING,
                 loc: locOf(inputNode),
             }
-            : L.coerceInto(inputNode, inputRef, STRING);
+            : lowerer.coerceInto(inputNode, inputRef, STRING);
         const answer = {
             kind: "libCall",
             fn: "fetch.start",
@@ -783,22 +712,22 @@ export function lowerFetchCall(L, call) {
     // through and dashed header keys ("content-type") are plain engine
     // property names. Non-literal inits marshal as a whole (JSON-safe
     // records; a signal field inside one fences with the boundary rule).
-    const args = call.arguments.map((a) => ts.isObjectLiteralExpression(a) ? lowerIslandObjectLiteral(L, a) : L.jsvalIn(L.lowerExpr(a), a));
+    const args = call.arguments.map((a) => ts.isObjectLiteralExpression(a) ? lowerIslandObjectLiteral(lowerer, a) : lowerer.jsvalIn(lowerer.lowerExpr(a), a));
     const raw = { kind: "jsOp", op: "callFn", args: [fetchFn, ...args], type: JSVAL, loc };
     return { kind: "jsBridgePromise", value: raw, type: { kind: "promise", inner: JSVAL }, loc };
 }
 /** Static Response.json(): consume the native Response's readable body
  * stream and parse its UTF-8 payload into the ordinary checked-dynamic
  * JSON tree. Syntax and stream failures reject at await like the web API. */
-export function lowerStaticResponseCall(L, call) {
-    if (L.dynamic ||
+export function lowerStaticResponseCall(lowerer, call) {
+    if (lowerer.dynamic ||
         call.questionDotToken ||
         (!ts.isPropertyAccessExpression(call.expression) &&
             !ts.isElementAccessExpression(call.expression))) {
         return null;
     }
     const access = call.expression;
-    const member = staticResponseMemberName(L, access);
+    const member = staticResponseMemberName(lowerer, access);
     if (access.questionDotToken ||
         (member !== "json" &&
             member !== "text" &&
@@ -807,17 +736,17 @@ export function lowerStaticResponseCall(L, call) {
         call.arguments.length !== 0) {
         return null;
     }
-    const recvType = L.checker.getBaseTypeOfLiteralType(L.typeOf(access.expression));
+    const recvType = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const sym = recvType.getAliasSymbol() ?? recvType.getSymbol();
-    if (!sym || sym.name !== "Response" || !L.isStdlibSymbol(sym))
+    if (!sym || sym.name !== "Response" || !lowerer.isStdlibSymbol(sym))
         return null;
     if (member === "arrayBuffer") {
-        L.noLowering("Response.arrayBuffer() in a static build", call, "use Response.bytes() for the native Uint8Array body; free-standing ArrayBuffer values have no static representation", sym);
+        lowerer.noLowering("Response.arrayBuffer() in a static build", call, "use Response.bytes() for the native Uint8Array body; free-standing ArrayBuffer values have no static representation", sym);
     }
-    const recv = L.lowerExpr(access.expression);
+    const recv = lowerer.lowerExpr(access.expression);
     if (recv.type.kind !== "dyn")
         return null;
-    return lowerStaticFixedFetchMethodCall(L, call, access, member, recv, [], (receiver) => member === "text" || member === "bytes"
+    return lowerStaticFixedFetchMethodCall(lowerer, call, access, member, recv, [], (receiver) => member === "text" || member === "bytes"
         ? {
             kind: "libCall",
             fn: member === "text" ? "fetch.responseText" : "fetch.responseBytes",
@@ -836,25 +765,25 @@ export function lowerStaticResponseCall(L, call) {
             loc: locOf(call),
         });
 }
-function staticResponseMemberName(L, access) {
+function staticResponseMemberName(lowerer, access) {
     if (ts.isPropertyAccessExpression(access))
         return access.name.text;
-    const members = fetchElementMemberNames(L, access.argumentExpression);
+    const members = fetchElementMemberNames(lowerer, access.argumentExpression);
     return members?.length === 1 ? members[0] : null;
 }
 /** A singleton computed member is still an evaluated JavaScript expression.
  * The specialized static bridges know the only permitted method name, but
  * must preserve receiver -> key -> arguments order and reject a lying cast
  * whose runtime key is not that name. */
-function lowerStaticFixedFetchMethodCall(L, call, access, member, receiver, argumentValues, invoke) {
+function lowerStaticFixedFetchMethodCall(lowerer, call, access, member, receiver, argumentValues, invoke) {
     if (ts.isPropertyAccessExpression(access)) {
         return invoke(receiver, [...argumentValues]);
     }
     const loc = locOf(call);
-    const key = L.lowerExprExpecting(access.argumentExpression, STRING);
-    const receiverLocal = L.declareHiddenLocal("%fetchReceiver", receiver.type);
-    const keyLocal = L.declareHiddenLocal("%fetchMember", STRING);
-    const argumentLocals = argumentValues.map((argument) => L.declareHiddenLocal("%fetchMethodArg", argument.type));
+    const key = lowerer.lowerExprExpecting(access.argumentExpression, STRING);
+    const receiverLocal = lowerer.declareHiddenLocal("%fetchReceiver", receiver.type);
+    const keyLocal = lowerer.declareHiddenLocal("%fetchMember", STRING);
+    const argumentLocals = argumentValues.map((argument) => lowerer.declareHiddenLocal("%fetchMethodArg", argument.type));
     const receiverRef = {
         kind: "varRef",
         localId: receiverLocal.id,
@@ -921,15 +850,15 @@ function lowerStaticFixedFetchMethodCall(L, call, access, member, receiver, argu
         loc,
     };
 }
-function fetchElementMemberNames(L, keyExpr) {
+function fetchElementMemberNames(lowerer, keyExpr) {
     if (ts.isPropertyAccessExpression(keyExpr) &&
-        L.isStdlibGlobal(keyExpr.expression, "Symbol") &&
+        lowerer.isStdlibGlobal(keyExpr.expression, "Symbol") &&
         (keyExpr.name.text === "iterator" ||
             keyExpr.name.text === "asyncIterator" ||
             keyExpr.name.text === "toStringTag")) {
         return [`[Symbol.${keyExpr.name.text}]`];
     }
-    const key = L.typeOf(keyExpr);
+    const key = lowerer.typeOf(keyExpr);
     if (key.isStringLiteralType())
         return [key.value];
     if (!key.isUnionType())
@@ -943,10 +872,10 @@ function fetchElementMemberNames(L, keyExpr) {
     }
     return members;
 }
-function fetchAccessMemberNames(L, access) {
+function fetchAccessMemberNames(lowerer, access) {
     return ts.isPropertyAccessExpression(access)
         ? [access.name.text]
-        : fetchElementMemberNames(L, access.argumentExpression);
+        : fetchElementMemberNames(lowerer, access.argumentExpression);
 }
 function fetchInventoryStatus(owner, member, placement) {
     return NODE24_FETCH_COMPAT_PROFILE.inventory.entries.find((entry) => entry.owner === owner &&
@@ -962,18 +891,18 @@ function fetchInventoryReason(owner, member, placement) {
  * methods. The inventory marks the former unsupported in both tiers; fence
  * them explicitly so the generic call fallback cannot report SC1090 for
  * Response.json while the other statics report SC2020. */
-export function fenceUnsupportedFetchConstructorMember(L, access) {
-    if (!L.isStdlibGlobal(access.expression, "Response"))
+export function fenceUnsupportedFetchConstructorMember(lowerer, access) {
+    if (!lowerer.isStdlibGlobal(access.expression, "Response"))
         return null;
-    const members = fetchAccessMemberNames(L, access);
+    const members = fetchAccessMemberNames(lowerer, access);
     if (members === null)
         return null;
     const member = members.find((candidate) => fetchInventoryStatus("Response", candidate, "static") === "unsupported");
     if (member === undefined)
         return null;
-    L.noLowering(`Response.${member}`, access, "Response static constructor-object operations have no compiler lowering in either tier");
+    lowerer.noLowering(`Response.${member}`, access, "Response static constructor-object operations have no compiler lowering in either tier");
 }
-function hasLiveWebMutableArm(L, type) {
+function hasLiveWebMutableArm(lowerer, type) {
     if (type.kind === "record" ||
         type.kind === "array" ||
         type.kind === "bytes") {
@@ -981,17 +910,17 @@ function hasLiveWebMutableArm(L, type) {
     }
     if (type.kind !== "union")
         return false;
-    return L.unions.get(type.unionId)?.arms.some((arm) => hasLiveWebMutableArm(L, arm)) ?? false;
+    return lowerer.unions.get(type.unionId)?.arms.some((arm) => hasLiveWebMutableArm(lowerer, arm)) ?? false;
 }
 /** Box mutable data for Web API slots that expose the exact JavaScript
  * value again. Ordinary dynFrom remains the documented copy boundary;
  * this capsule is deliberately limited to records/arrays/bytes (including
  * those selected at runtime from a union) that the live materializer can
  * snapshot and commit. */
-function lowerLiveWebValue(L, node, lowered) {
-    const value = lowered ?? L.lowerExpr(node);
-    if (hasLiveWebMutableArm(L, value.type) &&
-        canConvertToDyn(value.type, (id) => L.shapes.get(id), (id) => L.unions.get(id))) {
+function lowerLiveWebValue(lowerer, node, lowered) {
+    const value = lowered ?? lowerer.lowerExpr(node);
+    if (hasLiveWebMutableArm(lowerer, value.type) &&
+        canConvertToDyn(value.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
         return {
             kind: "dynFrom",
             value,
@@ -1000,7 +929,7 @@ function lowerLiveWebValue(L, node, lowered) {
             loc: value.loc,
         };
     }
-    return L.coerceInto(node, value, DYN);
+    return lowerer.coerceInto(node, value, DYN);
 }
 function fetchMethodArgumentIsLive(owner, members, index) {
     return ((index === 0 &&
@@ -1018,82 +947,82 @@ function fetchMethodArgumentIsLive(owner, members, index) {
  * handle. Keep the supported fallback slice on checked-dynamic dispatch, but
  * fence every other declared member before the generic dyn keyed-read/call
  * paths can turn a missing handle operation into a runtime TypeError. */
-export function fenceStaticResponseMember(L, access, use) {
-    const recvType = L.checker.getBaseTypeOfLiteralType(L.typeOf(access.expression));
+export function fenceStaticResponseMember(lowerer, access, use) {
+    const recvType = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const sym = recvType.getAliasSymbol() ?? recvType.getSymbol();
-    if (!sym || sym.name !== "Response" || !L.isStdlibSymbol(sym))
+    if (!sym || sym.name !== "Response" || !lowerer.isStdlibSymbol(sym))
         return null;
-    const members = fetchAccessMemberNames(L, access);
+    const members = fetchAccessMemberNames(lowerer, access);
     if (members === null)
         return null;
     const status = (member) => fetchInventoryStatus("Response", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype");
-    if (L.dynamic && members.every((member) => status(member) !== "unsupported")) {
+    if (lowerer.dynamic && members.every((member) => status(member) !== "unsupported")) {
         return null;
     }
     const supported = (member) => use === "call"
         ? STATIC_RESPONSE_CALLS.has(member)
         : STATIC_RESPONSE_READS.has(member);
-    if (!L.dynamic && members.every(supported))
+    if (!lowerer.dynamic && members.every(supported))
         return null;
-    const member = members.find((candidate) => L.dynamic ? status(candidate) === "unsupported" : !supported(candidate));
+    const member = members.find((candidate) => lowerer.dynamic ? status(candidate) === "unsupported" : !supported(candidate));
     if (status(member) === "unsupported") {
-        L.noLowering(`Response.${member}`, access, fetchInventoryReason("Response", member, "prototype") ??
+        lowerer.noLowering(`Response.${member}`, access, fetchInventoryReason("Response", member, "prototype") ??
             "this Response operation has no compiler lowering in either tier", sym);
     }
-    L.noLowering(`Response.${member} in a static build`, access, "the native static Response surface is status/ok/statusText/url/redirected/headers/body/bodyUsed plus json(), text(), and bytes(); use --dynamic for the wider Web API", sym);
+    lowerer.noLowering(`Response.${member} in a static build`, access, "the native static Response surface is status/ok/statusText/url/redirected/headers/body/bodyUsed plus json(), text(), and bytes(); use --dynamic for the wider Web API", sym);
 }
 /** Response Headers are native checked-dynamic handles. Keep their exact
  * supported method slice aligned with the compatibility census so newly
  * observed Node members cannot fall through to a runtime missing-method
  * error in an engine-free build. */
-export function fenceStaticHeadersMember(L, access, use) {
-    const recvType = L.checker.getBaseTypeOfLiteralType(L.typeOf(access.expression));
+export function fenceStaticHeadersMember(lowerer, access, use) {
+    const recvType = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const sym = recvType.getAliasSymbol() ?? recvType.getSymbol();
-    if (!sym || sym.name !== "Headers" || !L.isStdlibSymbol(sym))
+    if (!sym || sym.name !== "Headers" || !lowerer.isStdlibSymbol(sym))
         return null;
-    const members = fetchAccessMemberNames(L, access);
+    const members = fetchAccessMemberNames(lowerer, access);
     if (members === null)
         return null;
     const status = (member) => fetchInventoryStatus("Headers", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype");
-    if (L.dynamic && members.every((member) => status(member) !== "unsupported")) {
+    if (lowerer.dynamic && members.every((member) => status(member) !== "unsupported")) {
         return null;
     }
-    if (!L.dynamic && use === "call" && members.every((member) => STATIC_HEADERS_CALLS.has(member))) {
+    if (!lowerer.dynamic && use === "call" && members.every((member) => STATIC_HEADERS_CALLS.has(member))) {
         return null;
     }
-    const member = members.find((candidate) => L.dynamic
+    const member = members.find((candidate) => lowerer.dynamic
         ? status(candidate) === "unsupported"
         : use !== "call" || !STATIC_HEADERS_CALLS.has(candidate));
     if (status(member) === "unsupported") {
-        L.noLowering(`Headers.${member}`, access, "symbol-keyed Headers iteration has no compiler lowering in either tier; call entries() with --dynamic instead", sym);
+        lowerer.noLowering(`Headers.${member}`, access, "symbol-keyed Headers iteration has no compiler lowering in either tier; call entries() with --dynamic instead", sym);
     }
-    L.noLowering(`Headers.${member} in a static build`, access, "the native static Headers surface is append/delete/get/getSetCookie/has/set/forEach; use keys()/values()/entries() or symbol-keyed iteration with --dynamic, while construction remains unsupported", sym);
+    lowerer.noLowering(`Headers.${member} in a static build`, access, "the native static Headers surface is append/delete/get/getSetCookie/has/set/forEach; use keys()/values()/entries() or symbol-keyed iteration with --dynamic, while construction remains unsupported", sym);
 }
 /** The native AbortController handle dispatches `abort()` directly and
  * exposes `.signal` as data, but it has no first-class function value for
  * the prototype method. Fence method extraction before the checked-dynamic
  * keyed-read fallback can silently answer `undefined`. Dynamic builds use
  * the engine's real AbortController object and retain ordinary method reads. */
-export function fenceStaticAbortControllerMemberRead(L, access) {
-    if (L.dynamic)
+export function fenceStaticAbortControllerMemberRead(lowerer, access) {
+    if (lowerer.dynamic)
         return null;
-    const symbol = isStdlibFetchInterface(L, access.expression, "AbortController");
+    const symbol = isStdlibFetchInterface(lowerer, access.expression, "AbortController");
     if (!symbol)
         return null;
-    const members = fetchAccessMemberNames(L, access);
+    const members = fetchAccessMemberNames(lowerer, access);
     if (members === null || !members.includes("abort"))
         return null;
-    L.noLowering("AbortController.abort through method extraction in a static build", access, "call controller.abort(...) directly; the native AbortController handle does not expose abort as a first-class function value", symbol);
+    lowerer.noLowering("AbortController.abort through method extraction in a static build", access, "call controller.abort(...) directly; the native AbortController handle does not expose abort as a first-class function value", symbol);
 }
-function isStdlibFetchInterface(L, node, owner) {
-    const type = L.checker.getBaseTypeOfLiteralType(L.typeOf(node));
+function isStdlibFetchInterface(lowerer, node, owner) {
+    const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(node));
     for (const symbol of [type.getSymbol(), type.getAliasSymbol()]) {
-        if (symbol?.name === owner && L.isStdlibSymbol(symbol))
+        if (symbol?.name === owner && lowerer.isStdlibSymbol(symbol))
             return symbol;
     }
     return null;
 }
-function fetchObjectBindingMemberName(L, element) {
+function fetchObjectBindingMemberName(lowerer, element) {
     const name = element.propertyName ??
         (element.name !== undefined && ts.isIdentifier(element.name) ? element.name : undefined);
     if (name === undefined)
@@ -1105,12 +1034,12 @@ function fetchObjectBindingMemberName(L, element) {
     if (ts.isNumericLiteral(name))
         return String(Number(name.text));
     if (ts.isComputedPropertyName(name)) {
-        const members = fetchElementMemberNames(L, name.expression);
+        const members = fetchElementMemberNames(lowerer, name.expression);
         return members?.length === 1 ? members[0] : null;
     }
     return null;
 }
-function fetchObjectAssignmentMemberName(L, property) {
+function fetchObjectAssignmentMemberName(lowerer, property) {
     if (ts.isSpreadAssignment(property))
         return null;
     const name = property.name;
@@ -1121,20 +1050,20 @@ function fetchObjectAssignmentMemberName(L, property) {
     if (ts.isNumericLiteral(name))
         return String(Number(name.text));
     if (ts.isComputedPropertyName(name)) {
-        const members = fetchElementMemberNames(L, name.expression);
+        const members = fetchElementMemberNames(lowerer, name.expression);
         return members?.length === 1 ? members[0] : null;
     }
     return null;
 }
-function fetchInterfaceInventoryOwner(L, node) {
-    const type = L.checker.getBaseTypeOfLiteralType(L.typeOf(node));
+function fetchInterfaceInventoryOwner(lowerer, node) {
+    const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(node));
     const symbol = [type.getSymbol(), type.getAliasSymbol()].find((candidate) => candidate !== undefined &&
         NODE24_FETCH_COMPAT_PROFILE.inventory.interfaces.includes(candidate.name) &&
-        L.isStdlibSymbol(candidate));
+        lowerer.isStdlibSymbol(candidate));
     return symbol ? { owner: symbol.name, symbol } : null;
 }
-function fenceFetchObjectMembers(L, ownerNode, members) {
-    const resolved = fetchInterfaceInventoryOwner(L, ownerNode);
+function fenceFetchObjectMembers(lowerer, ownerNode, members) {
+    const resolved = fetchInterfaceInventoryOwner(lowerer, ownerNode);
     if (!resolved)
         return;
     const { owner, symbol } = resolved;
@@ -1146,16 +1075,16 @@ function fenceFetchObjectMembers(L, ownerNode, members) {
                 entry.placement === "prototype-symbol"));
         if (!row || row.status === "out-of-scope")
             continue;
-        if (L.dynamic && row.status !== "unsupported")
+        if (lowerer.dynamic && row.status !== "unsupported")
             continue;
         // Static data properties retain the ordinary checked-dynamic keyed-read
         // lowering. Only a method extraction loses the receiver that its direct
         // call bridge would preserve; non-static rows keep their inventory fence.
         const operation = NODE24_FETCH_COMPAT_PROFILE.operations.find((candidate) => candidate.id === row.id);
-        if (!L.dynamic && row.status === "static" && operation?.kind === "property") {
+        if (!lowerer.dynamic && row.status === "static" && operation?.kind === "property") {
             continue;
         }
-        L.noLowering(`${owner}.${member}${L.dynamic ? "" : " through object destructuring in a static build"}`, node, row.reason ??
+        lowerer.noLowering(`${owner}.${member}${lowerer.dynamic ? "" : " through object destructuring in a static build"}`, node, row.reason ??
             "the direct lowered read/call form has a compiler bridge, but extracting this member as a value does not", symbol);
     }
 }
@@ -1164,20 +1093,20 @@ function fenceFetchObjectMembers(L, ownerNode, members) {
  * see it. Attribute those reads to the same inventory rows before generic
  * dyn/jsval destructuring either reports SC1031 or admits an unsupported
  * member in the dynamic tier. */
-export function fenceFetchObjectBinding(L, pattern) {
-    fenceFetchObjectMembers(L, pattern, pattern.elements.flatMap((element) => {
+export function fenceFetchObjectBinding(lowerer, pattern) {
+    fenceFetchObjectMembers(lowerer, pattern, pattern.elements.flatMap((element) => {
         if (element.dotDotDotToken)
             return [];
-        const member = fetchObjectBindingMemberName(L, element);
+        const member = fetchObjectBindingMemberName(lowerer, element);
         return member === null ? [] : [{ member, node: element }];
     }));
 }
 /** Assignment-position object destructuring is the same member-read form as
  * a binding pattern, but its source type lives on the right-hand expression
  * instead of the target AST. */
-export function fenceFetchObjectAssignment(L, target, source) {
-    fenceFetchObjectMembers(L, source, target.properties.flatMap((property) => {
-        const member = fetchObjectAssignmentMemberName(L, property);
+export function fenceFetchObjectAssignment(lowerer, target, source) {
+    fenceFetchObjectMembers(lowerer, source, target.properties.flatMap((property) => {
+        const member = fetchObjectAssignmentMemberName(lowerer, property);
         return member === null ? [] : [{ member, node: property }];
     }));
 }
@@ -1186,29 +1115,29 @@ export function fenceFetchObjectAssignment(L, target, source) {
  * Keep engine-free builds on the same SC2020 profile row for for-of,
  * array spread, and array destructuring. The dynamic tier uses the
  * engine's iterator protocol and is intentionally allowed. */
-export function fenceStaticHeadersIteration(L, node) {
-    if (L.dynamic)
+export function fenceStaticHeadersIteration(lowerer, node) {
+    if (lowerer.dynamic)
         return;
     const value = ts.isExpression(node) ? requestInitValueExpr(node) : node;
-    const sym = isStdlibFetchInterface(L, value, "Headers");
+    const sym = isStdlibFetchInterface(lowerer, value, "Headers");
     if (!sym)
         return;
-    L.noLowering("Headers.[Symbol.iterator] in a static build", node, "Headers iteration requires --dynamic; append/delete/get/getSetCookie/has/set/forEach remain engine-free", sym);
+    lowerer.noLowering("Headers.[Symbol.iterator] in a static build", node, "Headers iteration requires --dynamic; append/delete/get/getSetCookie/has/set/forEach remain engine-free", sym);
 }
 /** Dynamic element-spelled Headers iteration. Symbol.iterator uses the
  * engine's GetIterator operation. A finite union of keys()/values()/entries()
  * dispatches through fixed-name engine calls after evaluating the receiver
  * and key once, preserving the method receiver and JavaScript evaluation
  * order without trying to represent the union of method values. */
-export function lowerDynamicHeadersIteratorCall(L, call, access) {
-    if (!L.dynamic ||
+export function lowerDynamicHeadersIteratorCall(lowerer, call, access) {
+    if (!lowerer.dynamic ||
         call.questionDotToken ||
         access.questionDotToken ||
         call.arguments.length !== 0 ||
-        !isStdlibFetchInterface(L, access.expression, "Headers")) {
+        !isStdlibFetchInterface(lowerer, access.expression, "Headers")) {
         return null;
     }
-    const members = fetchElementMemberNames(L, access.argumentExpression);
+    const members = fetchElementMemberNames(lowerer, access.argumentExpression);
     if (members === null)
         return null;
     const symbolIterator = members.length === 1 && members[0] === "[Symbol.iterator]";
@@ -1216,16 +1145,16 @@ export function lowerDynamicHeadersIteratorCall(L, call, access) {
         !members.every((member) => member === "keys" || member === "values" || member === "entries")) {
         return null;
     }
-    const receiver = L.lowerExpr(access.expression);
+    const receiver = lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "jsval")
         return null;
     const loc = locOf(call);
     if (!symbolIterator) {
-        const key = L.lowerExpr(access.argumentExpression);
+        const key = lowerer.lowerExpr(access.argumentExpression);
         if (key.type.kind !== "string")
             return null;
-        const recvLocal = L.declareHiddenLocal("%headers", JSVAL);
-        const keyLocal = L.declareHiddenLocal("%headersKey", STRING);
+        const recvLocal = lowerer.declareHiddenLocal("%headers", JSVAL);
+        const keyLocal = lowerer.declareHiddenLocal("%headersKey", STRING);
         const recvRef = {
             kind: "varRef",
             localId: recvLocal.id,
@@ -1295,7 +1224,7 @@ export function lowerDynamicHeadersIteratorCall(L, call, access) {
  * path (which correctly fences bare method extraction), evaluating receiver,
  * key, and arguments once in source order. Finite string-literal unions
  * dispatch through fixed-name calls after the key value is captured. */
-export function lowerFetchElementMethodCall(L, call) {
+export function lowerFetchElementMethodCall(lowerer, call) {
     if (call.questionDotToken ||
         !ts.isElementAccessExpression(call.expression) ||
         call.expression.questionDotToken ||
@@ -1303,10 +1232,10 @@ export function lowerFetchElementMethodCall(L, call) {
         return null;
     }
     const access = call.expression;
-    const resolved = fetchInterfaceInventoryOwner(L, access.expression);
+    const resolved = fetchInterfaceInventoryOwner(lowerer, access.expression);
     if (!resolved)
         return null;
-    const members = fetchElementMemberNames(L, access.argumentExpression);
+    const members = fetchElementMemberNames(lowerer, access.argumentExpression);
     if (members === null ||
         members.length === 0 ||
         members.some((member) => member.startsWith("[Symbol."))) {
@@ -1318,27 +1247,27 @@ export function lowerFetchElementMethodCall(L, call) {
             entry.placement === "prototype-inherited")));
     if (rows.some((row) => row === undefined ||
         row.status === "out-of-scope" ||
-        (L.dynamic ? row.status === "unsupported" : row.status !== "static"))) {
+        (lowerer.dynamic ? row.status === "unsupported" : row.status !== "static"))) {
         return null;
     }
-    const receiver = L.lowerExpr(access.expression);
-    if (receiver.type.kind !== (L.dynamic ? "jsval" : "dyn"))
+    const receiver = lowerer.lowerExpr(access.expression);
+    if (receiver.type.kind !== (lowerer.dynamic ? "jsval" : "dyn"))
         return null;
-    const key = L.lowerExpr(access.argumentExpression);
+    const key = lowerer.lowerExpr(access.argumentExpression);
     if (key.type.kind !== "string")
         return null;
     const loc = locOf(call);
-    const receiverLocal = L.declareHiddenLocal("%fetchReceiver", L.dynamic ? JSVAL : DYN);
-    const keyLocal = L.declareHiddenLocal("%fetchMember", STRING);
-    const calleeLocal = L.dynamic
-        ? L.declareHiddenLocal("%fetchMethod", JSVAL)
+    const receiverLocal = lowerer.declareHiddenLocal("%fetchReceiver", lowerer.dynamic ? JSVAL : DYN);
+    const keyLocal = lowerer.declareHiddenLocal("%fetchMember", STRING);
+    const calleeLocal = lowerer.dynamic
+        ? lowerer.declareHiddenLocal("%fetchMethod", JSVAL)
         : null;
-    const argumentValues = call.arguments.map((argument, index) => L.dynamic
-        ? L.jsvalIn(L.lowerExpr(argument), argument)
+    const argumentValues = call.arguments.map((argument, index) => lowerer.dynamic
+        ? lowerer.jsvalIn(lowerer.lowerExpr(argument), argument)
         : fetchMethodArgumentIsLive(resolved.owner, members, index)
-            ? lowerLiveWebValue(L, argument)
-            : L.lowerExprExpecting(argument, DYN));
-    const argumentLocals = argumentValues.map((argument) => L.declareHiddenLocal("%fetchMethodArg", argument.type));
+            ? lowerLiveWebValue(lowerer, argument)
+            : lowerer.lowerExprExpecting(argument, DYN));
+    const argumentLocals = argumentValues.map((argument) => lowerer.declareHiddenLocal("%fetchMethodArg", argument.type));
     const receiverRef = {
         kind: "varRef",
         localId: receiverLocal.id,
@@ -1392,7 +1321,7 @@ export function lowerFetchElementMethodCall(L, call) {
         type: argument.type,
         loc,
     }));
-    const staticResponsePromise = !L.dynamic &&
+    const staticResponsePromise = !lowerer.dynamic &&
         resolved.owner === "Response" &&
         call.arguments.length === 0 &&
         members.every((member) => member === "text" || member === "bytes")
@@ -1403,12 +1332,12 @@ export function lowerFetchElementMethodCall(L, call) {
             // result is the ordinary representable value union; use that
             // contextual type for the bridge's fulfillment adapter.
             const inner = ts.isAwaitExpression(call.parent)
-                ? L.mapTypeOf(L.typeOf(call.parent))
+                ? lowerer.mapTypeOf(lowerer.typeOf(call.parent))
                 : null;
             return inner ? { kind: "promise", inner } : null;
         })()
         : null;
-    const invoke = (member) => L.dynamic
+    const invoke = (member) => lowerer.dynamic
         ? {
             kind: "jsOp",
             op: "callFnThis",
@@ -1436,7 +1365,7 @@ export function lowerFetchElementMethodCall(L, call) {
     // Literal-string unions share the STRING carrier. A cast can therefore
     // smuggle a different runtime key into this call; validate all arms and
     // fail loudly rather than dispatching every mismatch to the last member.
-    const invocationType = staticResponsePromise ?? (L.dynamic ? JSVAL : DYN);
+    const invocationType = staticResponsePromise ?? (lowerer.dynamic ? JSVAL : DYN);
     let result = nodeThrowExpr(1, "", `${access.getText()} is not a function`, invocationType, loc);
     for (let index = members.length - 1; index >= 0; index--) {
         const member = members[index];
@@ -1456,7 +1385,7 @@ export function lowerFetchElementMethodCall(L, call) {
             loc,
         };
     }
-    const declared = L.dynamic ? L.mapTypeOf(L.typeOf(call)) : null;
+    const declared = lowerer.dynamic ? lowerer.mapTypeOf(lowerer.typeOf(call)) : null;
     if (declared &&
         (declared.kind === "f64" ||
             declared.kind === "bool" ||
@@ -1485,11 +1414,11 @@ export function lowerFetchElementMethodCall(L, call) {
  * over the real Headers iterator, then the resulting pair array exits
  * through the checker's declared array type. For Headers this is the
  * spread algorithm's exact iterable snapshot. */
-export function lowerDynamicHeadersSpread(L, node, type) {
-    if (!L.dynamic || !isStdlibFetchInterface(L, requestInitValueExpr(node), "Headers")) {
+export function lowerDynamicHeadersSpread(lowerer, node, type) {
+    if (!lowerer.dynamic || !isStdlibFetchInterface(lowerer, requestInitValueExpr(node), "Headers")) {
         return null;
     }
-    const receiver = L.lowerExpr(node);
+    const receiver = lowerer.lowerExpr(node);
     if (receiver.type.kind !== "jsval")
         return null;
     const loc = locOf(node);
@@ -1515,37 +1444,37 @@ export function lowerDynamicHeadersSpread(L, node, type) {
  * stream slice, but @types/node adopts the complete WHATWG ReadableStream
  * interface. Fence that wider surface before its checked-dynamic handle can
  * fall through to a runtime missing-method error. */
-export function fenceStaticReadableStreamMember(L, access, use) {
-    const sym = isStdlibFetchInterface(L, access.expression, "ReadableStream");
+export function fenceStaticReadableStreamMember(lowerer, access, use) {
+    const sym = isStdlibFetchInterface(lowerer, access.expression, "ReadableStream");
     if (!sym)
         return null;
-    const members = fetchAccessMemberNames(L, access);
+    const members = fetchAccessMemberNames(lowerer, access);
     if (members === null)
         return null;
     const status = (member) => fetchInventoryStatus("ReadableStream", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype");
-    if (L.dynamic && members.every((member) => status(member) !== "unsupported")) {
+    if (lowerer.dynamic && members.every((member) => status(member) !== "unsupported")) {
         return null;
     }
     const supported = (member) => use === "call"
         ? STATIC_READABLE_STREAM_CALLS.has(member)
         : STATIC_READABLE_STREAM_READS.has(member);
-    if (!L.dynamic && members.every(supported))
+    if (!lowerer.dynamic && members.every(supported))
         return null;
-    const member = members.find((candidate) => L.dynamic ? status(candidate) === "unsupported" : !supported(candidate));
+    const member = members.find((candidate) => lowerer.dynamic ? status(candidate) === "unsupported" : !supported(candidate));
     if (status(member) === "unsupported") {
-        L.noLowering(`ReadableStream.${member}`, access, fetchInventoryReason("ReadableStream", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype") ?? "this ReadableStream operation has no compiler lowering in either tier", sym);
+        lowerer.noLowering(`ReadableStream.${member}`, access, fetchInventoryReason("ReadableStream", member, member.startsWith("[Symbol.") ? "prototype-symbol" : "prototype") ?? "this ReadableStream operation has no compiler lowering in either tier", sym);
     }
-    L.noLowering(`ReadableStream.${member} in a static build`, access, "the native static ReadableStream surface is locked plus cancel() and getReader(); use a reader directly or --dynamic for the wider Web Streams API", sym);
+    lowerer.noLowering(`ReadableStream.${member} in a static build`, access, "the native static ReadableStream surface is locked plus cancel() and getReader(); use a reader directly or --dynamic for the wider Web Streams API", sym);
 }
 /** Static AbortSignal constructors and ReadableStream.from(). These
  * ambient globals have no first-class constructor-object representation;
  * claim the direct calls by declaration provenance before the general
  * member-call path tries to lower the receiver as a value. */
-function staticFirstArgWithSurplusArgs(L, call, first) {
+function staticFirstArgWithSurplusArgs(lowerer, call, first) {
     const loc = locOf(call);
     if (call.arguments.length <= 1)
         return first;
-    const firstLocal = L.declareHiddenLocal("%fetchArg", first.type);
+    const firstLocal = lowerer.declareHiddenLocal("%fetchArg", first.type);
     const firstRef = {
         kind: "varRef",
         localId: firstLocal.id,
@@ -1557,14 +1486,14 @@ function staticFirstArgWithSurplusArgs(L, call, first) {
     ];
     for (const argument of call.arguments.slice(1)) {
         if (ts.isSpreadElement(argument)) {
-            L.noLowering("spread surplus arguments on the static fetch companion APIs", argument, "pass surplus arguments without spread syntax");
+            lowerer.noLowering("spread surplus arguments on the static fetch companion APIs", argument, "pass surplus arguments without spread syntax");
         }
         // The callee ignores the value, but JavaScript still evaluates every
         // surplus argument in source order. A direct void has the operand's
         // effects and no additional work of its own.
         const discarded = ts.isVoidExpression(argument)
-            ? L.lowerExpr(argument.expression)
-            : L.lowerExpr(argument);
+            ? lowerer.lowerExpr(argument.expression)
+            : lowerer.lowerExpr(argument);
         stmts.push({ kind: "exprStmt", expr: discarded, loc: discarded.loc });
     }
     return {
@@ -1575,11 +1504,11 @@ function staticFirstArgWithSurplusArgs(L, call, first) {
         loc,
     };
 }
-function staticCallWithSurplusArgs(L, call, first, result) {
-    return result(staticFirstArgWithSurplusArgs(L, call, first));
+function staticCallWithSurplusArgs(lowerer, call, first, result) {
+    return result(staticFirstArgWithSurplusArgs(lowerer, call, first));
 }
-export function lowerStaticFetchCompanionCall(L, call) {
-    if (L.dynamic ||
+export function lowerStaticFetchCompanionCall(lowerer, call) {
+    if (lowerer.dynamic ||
         call.questionDotToken ||
         !ts.isPropertyAccessExpression(call.expression) ||
         call.expression.questionDotToken ||
@@ -1587,8 +1516,8 @@ export function lowerStaticFetchCompanionCall(L, call) {
         return null;
     }
     const root = call.expression.expression;
-    const symbol = L.resolveValueSymbol(root);
-    if (!symbol || !L.isStdlibSymbol(symbol))
+    const symbol = lowerer.resolveValueSymbol(root);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
     const loc = locOf(call);
     if (root.text === "AbortSignal") {
@@ -1597,8 +1526,8 @@ export function lowerStaticFetchCompanionCall(L, call) {
                 if (call.arguments[0] && ts.isSpreadElement(call.arguments[0])) {
                     return null;
                 }
-                return staticCallWithSurplusArgs(L, call, call.arguments[0]
-                    ? L.lowerExprExpecting(call.arguments[0], DYN)
+                return staticCallWithSurplusArgs(lowerer, call, call.arguments[0]
+                    ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
                     : dynUndefinedExpr(loc), (first) => ({
                     kind: "libCall",
                     fn: "fetch.abortTimeout",
@@ -1618,7 +1547,7 @@ export function lowerStaticFetchCompanionCall(L, call) {
                 }
                 if (ts.isSpreadElement(call.arguments[0]))
                     return null;
-                return staticCallWithSurplusArgs(L, call, lowerLiveWebValue(L, call.arguments[0]), (first) => ({
+                return staticCallWithSurplusArgs(lowerer, call, lowerLiveWebValue(lowerer, call.arguments[0]), (first) => ({
                     kind: "libCall",
                     fn: "fetch.abortNow",
                     args: [first],
@@ -1629,8 +1558,8 @@ export function lowerStaticFetchCompanionCall(L, call) {
                 if (call.arguments[0] && ts.isSpreadElement(call.arguments[0])) {
                     return null;
                 }
-                return staticCallWithSurplusArgs(L, call, call.arguments[0]
-                    ? L.lowerExprExpecting(call.arguments[0], DYN)
+                return staticCallWithSurplusArgs(lowerer, call, call.arguments[0]
+                    ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
                     : dynUndefinedExpr(loc), (first) => ({
                     kind: "libCall",
                     fn: "fetch.abortAny",
@@ -1654,31 +1583,31 @@ export function lowerStaticFetchCompanionCall(L, call) {
                 loc,
             };
         }
-        let source = L.lowerExpr(call.arguments[0]);
+        let source = lowerer.lowerExpr(call.arguments[0]);
         // A readonly tuple satisfies the fallback's readonly-array overload,
         // but maps to a monomorphic record in IR. Reuse the ordinary
         // tuple→array width conversion with the resolved generic parameter so
         // `ReadableStream.from([1, 2] as const)` follows every other tuple
         // flowing into a readonly T[] slot.
         if (source.type.kind === "record") {
-            const signature = L.checker.getResolvedSignature(call);
+            const signature = lowerer.checker.getResolvedSignature(call);
             const iterableParam = signature?.getParameters()[0];
             const iterableType = iterableParam
-                ? L.mapTypeOf(L.checker.getTypeOfSymbol(iterableParam))
+                ? lowerer.mapTypeOf(lowerer.checker.getTypeOfSymbol(iterableParam))
                 : null;
             if (iterableType?.kind === "array") {
-                source = L.widthCoerce(source, iterableType) ?? source;
+                source = lowerer.widthCoerce(source, iterableType) ?? source;
             }
         }
         const preserve = source.type.kind === "string" ||
             (source.type.kind === "bytes" && source.type.elem === "u8") ||
             (source.type.kind === "array" &&
-                canConvertToDyn(source.type.elem, (id) => L.shapes.get(id), (id) => L.unions.get(id))) ||
+                canConvertToDyn(source.type.elem, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) ||
             source.type.kind === "dyn";
         if (!preserve) {
-            L.noLowering(`ReadableStream.from() over ${L.checker.typeToString(L.typeOf(call.arguments[0]))} iterables`, call.arguments[0], "arrays, Uint8Array, and strings are supported — spread other synchronous iterables into an array first: [...iterable]");
+            lowerer.noLowering(`ReadableStream.from() over ${lowerer.checker.typeToString(lowerer.typeOf(call.arguments[0]))} iterables`, call.arguments[0], "arrays, Uint8Array, and strings are supported — spread other synchronous iterables into an array first: [...iterable]");
         }
-        return staticCallWithSurplusArgs(L, call, source, (first) => ({
+        return staticCallWithSurplusArgs(lowerer, call, source, (first) => ({
             kind: "libCall",
             fn: "fetch.streamFrom",
             // Arrays and bytes must cross by reference: their iterators read each
@@ -1696,33 +1625,33 @@ export function lowerStaticFetchCompanionCall(L, call) {
  * `.signal` and fetch. Preserve a mutable reason's identity just like
  * `AbortSignal.abort(reason)`; surplus arguments still evaluate in order and
  * are ignored by the runtime operation. */
-export function lowerStaticAbortControllerCall(L, call) {
+export function lowerStaticAbortControllerCall(lowerer, call) {
     const access = call.expression;
-    if (L.dynamic ||
+    if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
         (!ts.isPropertyAccessExpression(access) &&
             !ts.isElementAccessExpression(access)) ||
         access.questionDotToken ||
-        staticResponseMemberName(L, access) !== "abort") {
+        staticResponseMemberName(lowerer, access) !== "abort") {
         return null;
     }
-    const receiverTs = L.checker.getBaseTypeOfLiteralType(L.typeOf(access.expression));
+    const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
     if (symbol?.name !== "AbortController" ||
-        !L.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            L.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
+            lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
-    const receiver = L.lowerExpr(access.expression);
+    const receiver = lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "dyn")
         return null;
     const loc = locOf(call);
     const first = call.arguments[0]
-        ? lowerLiveWebValue(L, call.arguments[0])
+        ? lowerLiveWebValue(lowerer, call.arguments[0])
         : dynUndefinedExpr(loc);
-    const args = [staticFirstArgWithSurplusArgs(L, call, first)];
-    return lowerStaticFixedFetchMethodCall(L, call, access, "abort", receiver, args, (receiverRef, argumentRefs) => ({
+    const args = [staticFirstArgWithSurplusArgs(lowerer, call, first)];
+    return lowerStaticFixedFetchMethodCall(lowerer, call, access, "abort", receiver, args, (receiverRef, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiverRef,
         method: "abort",
@@ -1735,9 +1664,9 @@ export function lowerStaticAbortControllerCall(L, call) {
 /** Controller chunks and error reasons are dyn-handle calls, but unlike a
  * general checked-dynamic boundary the Web Streams contract preserves their
  * object identity for the reader/source callbacks that observe them. */
-export function lowerStaticReadableStreamControllerCall(L, call) {
+export function lowerStaticReadableStreamControllerCall(lowerer, call) {
     const access = call.expression;
-    if (L.dynamic ||
+    if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.length > 1 ||
         (!ts.isPropertyAccessExpression(access) &&
@@ -1745,26 +1674,26 @@ export function lowerStaticReadableStreamControllerCall(L, call) {
         access.questionDotToken) {
         return null;
     }
-    const member = staticResponseMemberName(L, access);
+    const member = staticResponseMemberName(lowerer, access);
     if (member !== "enqueue" && member !== "error")
         return null;
-    const receiverTs = L.checker.getBaseTypeOfLiteralType(L.typeOf(access.expression));
+    const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
     if (symbol?.name !== "ReadableStreamDefaultController" ||
-        !L.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            L.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
+            lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
-    const recv = L.lowerExpr(access.expression);
+    const recv = lowerer.lowerExpr(access.expression);
     if (recv.type.kind !== "dyn")
         return null;
     const loc = locOf(call);
     const args = [
         call.arguments[0]
-            ? lowerLiveWebValue(L, call.arguments[0])
+            ? lowerLiveWebValue(lowerer, call.arguments[0])
             : dynUndefinedExpr(loc),
     ];
-    return lowerStaticFixedFetchMethodCall(L, call, access, member, recv, args, (receiver, argumentRefs) => ({
+    return lowerStaticFixedFetchMethodCall(lowerer, call, access, member, recv, args, (receiver, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiver,
         method: member,
@@ -1777,33 +1706,33 @@ export function lowerStaticReadableStreamControllerCall(L, call) {
 /** `ReadableStream.cancel(reason)` and default-reader `cancel(reason)` pass
  * the same reason object to the underlying source's cancel callback. Keep a
  * live typed-reference capsule instead of the general dyn boundary's copy. */
-export function lowerStaticReadableStreamCancelCall(L, call) {
+export function lowerStaticReadableStreamCancelCall(lowerer, call) {
     const access = call.expression;
-    if (L.dynamic ||
+    if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.length > 1 ||
         call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
         (!ts.isPropertyAccessExpression(access) &&
             !ts.isElementAccessExpression(access)) ||
         access.questionDotToken ||
-        staticResponseMemberName(L, access) !== "cancel") {
+        staticResponseMemberName(lowerer, access) !== "cancel") {
         return null;
     }
-    const resolved = fetchInterfaceInventoryOwner(L, access.expression);
+    const resolved = fetchInterfaceInventoryOwner(lowerer, access.expression);
     if (resolved?.owner !== "ReadableStream" &&
         resolved?.owner !== "ReadableStreamDefaultReader") {
         return null;
     }
-    const receiver = L.lowerExpr(access.expression);
+    const receiver = lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "dyn")
         return null;
     const loc = locOf(call);
     const args = [
         call.arguments[0]
-            ? lowerLiveWebValue(L, call.arguments[0])
+            ? lowerLiveWebValue(lowerer, call.arguments[0])
             : dynUndefinedExpr(loc),
     ];
-    return lowerStaticFixedFetchMethodCall(L, call, access, "cancel", receiver, args, (receiverRef, argumentRefs) => ({
+    return lowerStaticFixedFetchMethodCall(lowerer, call, access, "cancel", receiver, args, (receiverRef, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiverRef,
         method: "cancel",
@@ -1817,9 +1746,9 @@ export function lowerStaticReadableStreamCancelCall(L, call) {
  * removeEventListener(). Functions already box by closure identity; mutable
  * record/array/bytes listeners need the same live capsule used by stream
  * chunks so repeated crossings still denote one EventListener object. */
-export function lowerStaticAbortSignalListenerCall(L, call) {
+export function lowerStaticAbortSignalListenerCall(lowerer, call) {
     const access = call.expression;
-    if (L.dynamic ||
+    if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.length < 2 ||
         call.arguments.some((arg) => ts.isSpreadElement(arg)) ||
@@ -1828,25 +1757,25 @@ export function lowerStaticAbortSignalListenerCall(L, call) {
         access.questionDotToken) {
         return null;
     }
-    const member = staticResponseMemberName(L, access);
+    const member = staticResponseMemberName(lowerer, access);
     if (member !== "addEventListener" && member !== "removeEventListener") {
         return null;
     }
-    const receiverTs = L.checker.getBaseTypeOfLiteralType(L.typeOf(access.expression));
+    const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
     if (symbol?.name !== "AbortSignal" ||
-        !L.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            L.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
+            lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
-    const recv = L.lowerExpr(access.expression);
+    const recv = lowerer.lowerExpr(access.expression);
     if (recv.type.kind !== "dyn")
         return null;
     const loc = locOf(call);
     const args = call.arguments.map((arg, index) => index === 1
-        ? lowerLiveWebValue(L, arg)
-        : L.lowerExprExpecting(arg, DYN));
-    return lowerStaticFixedFetchMethodCall(L, call, access, member, recv, args, (receiver, argumentRefs) => ({
+        ? lowerLiveWebValue(lowerer, arg)
+        : lowerer.lowerExprExpecting(arg, DYN));
+    return lowerStaticFixedFetchMethodCall(lowerer, call, access, member, recv, args, (receiver, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiver,
         method: member,
@@ -1860,19 +1789,19 @@ export function lowerStaticAbortSignalListenerCall(L, call) {
  * over the same signal state consumed by fetch; dynamic builds construct the
  * island Web object. JavaScript accepts surplus constructor arguments, so
  * both tiers evaluate them even though AbortController ignores their values. */
-export function lowerAbortControllerNew(L, expr) {
+export function lowerAbortControllerNew(lowerer, expr) {
     if (!ts.isIdentifier(expr.expression) ||
         expr.expression.text !== "AbortController") {
         return null;
     }
-    const symbol = L.resolveValueSymbol(expr.expression);
-    if (!symbol || !L.isStdlibSymbol(symbol))
+    const symbol = lowerer.resolveValueSymbol(expr.expression);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
     const args = expr.arguments ?? [];
     if (args.some((argument) => ts.isSpreadElement(argument)))
         return null;
     const loc = locOf(expr);
-    if (L.dynamic) {
+    if (lowerer.dynamic) {
         const ctor = {
             kind: "jsOp",
             op: "globalGet",
@@ -1884,7 +1813,7 @@ export function lowerAbortControllerNew(L, expr) {
         return {
             kind: "jsOp",
             op: "construct",
-            args: [ctor, ...args.map((argument) => L.jsvalIn(L.lowerExpr(argument), argument))],
+            args: [ctor, ...args.map((argument) => lowerer.jsvalIn(lowerer.lowerExpr(argument), argument))],
             type: JSVAL,
             loc,
         };
@@ -1902,7 +1831,7 @@ export function lowerAbortControllerNew(L, expr) {
         kind: "seqExpr",
         stmts: args.map((argument) => ({
             kind: "exprStmt",
-            expr: L.lowerExpr(argument),
+            expr: lowerer.lowerExpr(argument),
             loc: locOf(argument),
         })),
         result,
@@ -1913,19 +1842,19 @@ export function lowerAbortControllerNew(L, expr) {
 /** `new ReadableStream(source?)`. Static builds box the source record into
  * the checked-dynamic tree; dynamic builds construct the island's Web
  * stream directly so the returned handle composes with dynamic fetch. */
-export function lowerStaticReadableStreamNew(L, expr) {
+export function lowerStaticReadableStreamNew(lowerer, expr) {
     if (!ts.isIdentifier(expr.expression) ||
         expr.expression.text !== "ReadableStream") {
         return null;
     }
-    const symbol = L.resolveValueSymbol(expr.expression);
-    if (!symbol || !L.isStdlibSymbol(symbol))
+    const symbol = lowerer.resolveValueSymbol(expr.expression);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
     const args = expr.arguments ?? [];
     if (args.length > 1)
         return null;
     const loc = locOf(expr);
-    if (L.dynamic) {
+    if (lowerer.dynamic) {
         const ctor = {
             kind: "jsOp",
             op: "globalGet",
@@ -1937,8 +1866,8 @@ export function lowerStaticReadableStreamNew(L, expr) {
         const source = args[0] === undefined
             ? null
             : ts.isObjectLiteralExpression(args[0])
-                ? lowerIslandObjectLiteral(L, args[0])
-                : L.jsvalIn(L.lowerExpr(args[0]), args[0]);
+                ? lowerIslandObjectLiteral(lowerer, args[0])
+                : lowerer.jsvalIn(lowerer.lowerExpr(args[0]), args[0]);
         return {
             kind: "jsOp",
             op: "construct",
@@ -1950,8 +1879,8 @@ export function lowerStaticReadableStreamNew(L, expr) {
     const source = args.length === 0
         ? dynUndefinedExpr(loc)
         : ts.isObjectLiteralExpression(args[0])
-            ? lowerDynObjectLiteral(L, args[0])
-            : lowerLiveWebValue(L, args[0]);
+            ? lowerDynObjectLiteral(lowerer, args[0])
+            : lowerLiveWebValue(lowerer, args[0]);
     return {
         kind: "libCall",
         fn: "fetch.streamNew",
@@ -1964,19 +1893,19 @@ export function lowerStaticReadableStreamNew(L, expr) {
  * Web Response directly. Static builds hand a checked-dynamic BodyInit and
  * ResponseInit snapshot to the native fetch runtime, which returns the same
  * opaque Response handle as fetch(). */
-export function lowerResponseNew(L, expr) {
+export function lowerResponseNew(lowerer, expr) {
     if (!ts.isIdentifier(expr.expression) ||
         expr.expression.text !== "Response") {
         return null;
     }
-    const symbol = L.resolveValueSymbol(expr.expression);
-    if (!symbol || !L.isStdlibSymbol(symbol))
+    const symbol = lowerer.resolveValueSymbol(expr.expression);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
     const args = expr.arguments ?? [];
     if (args.some(ts.isSpreadElement))
         return null;
     const loc = locOf(expr);
-    if (L.dynamic) {
+    if (lowerer.dynamic) {
         const ctor = {
             kind: "jsOp",
             op: "globalGet",
@@ -1986,8 +1915,8 @@ export function lowerResponseNew(L, expr) {
             loc,
         };
         const lowered = args.map((arg) => ts.isObjectLiteralExpression(arg)
-            ? lowerIslandObjectLiteral(L, arg)
-            : L.jsvalIn(L.lowerExpr(arg), arg));
+            ? lowerIslandObjectLiteral(lowerer, arg)
+            : lowerer.jsvalIn(lowerer.lowerExpr(arg), arg));
         return {
             kind: "jsOp",
             op: "construct",
@@ -2007,25 +1936,25 @@ export function lowerResponseNew(L, expr) {
          * deliberately declines accessors/methods, whose observable reads
          * cannot be moved into the runtime WebIDL conversion phase. */
         if (what === "an init value" && value.type.kind === "object") {
-            const sourceType = L.typeOf(node);
+            const sourceType = lowerer.typeOf(node);
             const fields = [];
             for (const name of ["headers", "status", "statusText"]) {
-                const property = L.checker.getPropertyOfType(sourceType, name);
+                const property = lowerer.checker.getPropertyOfType(sourceType, name);
                 if (!property)
                     continue;
-                const propertyType = L.checker.getTypeOfSymbolAtLocation(property, node);
-                const mapped = L.mapTypeOf(propertyType);
+                const propertyType = lowerer.checker.getTypeOfSymbolAtLocation(property, node);
+                const mapped = lowerer.mapTypeOf(propertyType);
                 if (!mapped || mapped.kind === "void") {
-                    L.noLowering(`new Response with ${what} of type '${L.fmt(value.type)}'`, node, `the '${name}' field does not have a checked-dynamic representation`);
+                    lowerer.noLowering(`new Response with ${what} of type '${lowerer.fmt(value.type)}'`, node, `the '${name}' field does not have a checked-dynamic representation`);
                 }
                 fields.push({ name, type: mapped });
             }
             const recordType = {
                 kind: "record",
-                shapeId: L.shapes.intern(fields, false, undefined, fields.map((field) => field.name)),
+                shapeId: lowerer.shapes.intern(fields, false, undefined, fields.map((field) => field.name)),
             };
-            const projected = L.widthCoerce(value, recordType);
-            if (projected && L.dynConvertible(projected.type)) {
+            const projected = lowerer.widthCoerce(value, recordType);
+            if (projected && lowerer.dynConvertible(projected.type)) {
                 return {
                     kind: "dynFrom",
                     value: projected,
@@ -2035,9 +1964,9 @@ export function lowerResponseNew(L, expr) {
                 };
             }
         }
-        if (value.kind === "unitLit" || L.dynConvertible(value.type)) {
+        if (value.kind === "unitLit" || lowerer.dynConvertible(value.type)) {
             if (what === "an init value" &&
-                hasLiveWebMutableArm(L, value.type)) {
+                hasLiveWebMutableArm(lowerer, value.type)) {
                 return {
                     kind: "dynFrom",
                     value,
@@ -2053,18 +1982,18 @@ export function lowerResponseNew(L, expr) {
                 loc: value.loc,
             };
         }
-        L.noLowering(`new Response with ${what} of type '${L.fmt(value.type)}'`, node, "the static constructor accepts string, Uint8Array, ReadableStream, null, and the declared ResponseInit dictionary");
+        lowerer.noLowering(`new Response with ${what} of type '${lowerer.fmt(value.type)}'`, node, "the static constructor accepts string, Uint8Array, ReadableStream, null, and the declared ResponseInit dictionary");
     };
     const bodyNode = args[0];
     const body = bodyNode === undefined
         ? { kind: "unitLit", unit: "undefined", type: { kind: "undefinedT" }, loc }
-        : L.lowerExpr(bodyNode);
+        : lowerer.lowerExpr(bodyNode);
     const initNode = args[1];
     const init = initNode === undefined
         ? { kind: "unitLit", unit: "undefined", type: { kind: "undefinedT" }, loc }
         : ts.isObjectLiteralExpression(initNode)
-            ? lowerDynObjectLiteral(L, initNode, (node, value) => lowerLiveWebValue(L, node, value))
-            : L.lowerExpr(initNode);
+            ? lowerDynObjectLiteral(lowerer, initNode, (node, value) => lowerLiveWebValue(lowerer, node, value))
+            : lowerer.lowerExpr(initNode);
     /* JavaScript evaluates every argument expression before WebIDL starts
      * converting either BodyInit or ResponseInit. Capture the raw values in
      * source order; only the final libCall boxes the body and gives typed init
@@ -2087,7 +2016,7 @@ export function lowerResponseNew(L, expr) {
                     loc: value.loc,
                 };
         }
-        const local = L.declareHiddenLocal(name, value.type);
+        const local = lowerer.declareHiddenLocal(name, value.type);
         stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc });
         return {
             kind: "varRef",
@@ -2100,8 +2029,8 @@ export function lowerResponseNew(L, expr) {
     const initRef = capture(init, "%responseInit");
     for (const argument of args.slice(2)) {
         const discarded = ts.isVoidExpression(argument)
-            ? L.lowerExpr(argument.expression)
-            : L.lowerExpr(argument);
+            ? lowerer.lowerExpr(argument.expression)
+            : lowerer.lowerExpr(argument);
         stmts.push({ kind: "exprStmt", expr: discarded, loc: discarded.loc });
     }
     const result = {
@@ -2120,9 +2049,9 @@ export function lowerResponseNew(L, expr) {
  * transport into the checker's concrete chunk type. An exact chunk type
  * preserves ReadableStream.from(array)'s element identity; structural
  * widening keeps the compiler's ordinary copy-based width semantics. */
-export function lowerStaticReadableStreamReaderCall(L, call) {
+export function lowerStaticReadableStreamReaderCall(lowerer, call) {
     const access = call.expression;
-    if (L.dynamic ||
+    if (lowerer.dynamic ||
         call.questionDotToken ||
         call.arguments.length !== 0 ||
         (!ts.isPropertyAccessExpression(access) &&
@@ -2130,23 +2059,23 @@ export function lowerStaticReadableStreamReaderCall(L, call) {
         access.questionDotToken) {
         return null;
     }
-    const member = staticResponseMemberName(L, access);
+    const member = staticResponseMemberName(lowerer, access);
     if (member !== "read")
         return null;
-    const receiverTs = L.typeOf(access.expression);
+    const receiverTs = lowerer.typeOf(access.expression);
     const symbol = receiverTs.getSymbol();
     if (symbol?.name !== "ReadableStreamDefaultReader" ||
-        !L.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
-            L.isStdlibFile(d.getSourceFile()))) {
+        !lowerer.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
+            lowerer.isStdlibFile(d.getSourceFile()))) {
         return null;
     }
-    const type = L.mapTypeOf(L.typeOf(call));
+    const type = lowerer.mapTypeOf(lowerer.typeOf(call));
     if (type?.kind !== "promise" ||
         type.inner.kind !== "record") {
         return null;
     }
-    const receiver = L.lowerExprExpecting(access.expression, DYN);
-    return lowerStaticFixedFetchMethodCall(L, call, access, "read", receiver, [], (receiverRef) => ({
+    const receiver = lowerer.lowerExprExpecting(access.expression, DYN);
+    return lowerStaticFixedFetchMethodCall(lowerer, call, access, "read", receiver, [], (receiverRef) => ({
         kind: "libCall",
         fn: "fetch.readerRead",
         args: [receiverRef],
@@ -2167,27 +2096,27 @@ export function lowerStaticReadableStreamReaderCall(L, call) {
    * graph is a BUILD-time artifact — a runtime-computed name has nothing
    * to embed, and the fence says so. Static builds report the per-site
    * SC2012. Null for anything that isn't `import(...)`. */
-export function lowerDynamicImportCall(L, call) {
+export function lowerDynamicImportCall(lowerer, call) {
     if (call.expression.kind !== ts.SyntaxKind.ImportKeyword)
         return null;
-    L.requireDynamicApi("'import()'", call);
+    lowerer.requireDynamicApi("'import()'", call);
     const loc = locOf(call);
     const arg = call.arguments[0];
     if (arg === undefined || !ts.isStringLiteralLike(arg)) {
-        L.unsupported("SC1090", call, "dynamic import() of computed specifiers (the module graph embeds at " +
+        lowerer.unsupported("SC1090", call, "dynamic import() of computed specifiers (the module graph embeds at " +
             "build time — the specifier must be a string literal)");
     }
     if (call.arguments.length !== 1) {
-        L.unsupported("SC1090", call, "dynamic import() with import attributes");
+        lowerer.unsupported("SC1090", call, "dynamic import() with import attributes");
     }
-    const res = L.dynImports.get(`${call.getSourceFile().fileName}\u0000${arg.text}`);
+    const res = lowerer.dynImports.get(`${call.getSourceFile().fileName}\u0000${arg.text}`);
     if (!res) {
         // Collection walks every file before bodies lower, so a missing
         // entry is a lowerer bug, not user error.
-        throw new Error(`lowerer bug: unresolved dynamic import '${arg.text}'`);
+        throw new InternalCompilerError(`lowerer bug: unresolved dynamic import '${arg.text}'`);
     }
     if (res.kind === "program-module") {
-        return lowerOwnModuleImport(L, call, arg);
+        return lowerOwnModuleImport(lowerer, call, arg);
     }
     if (res.kind !== "module") {
         throw new PoisonError(); // resolution failed — collection reported it
@@ -2217,29 +2146,29 @@ export function lowerDynamicImportCall(L, call) {
    * signatures) cross as trap functions that throw a pointed TypeError
    * when USED — the namespace still builds, exactly like Node still
    * resolves it. */
-function lowerOwnModuleImport(L, call, arg) {
+function lowerOwnModuleImport(lowerer, call, arg) {
     const loc = locOf(call);
     let dep = null;
-    const modSym = L.checker.getSymbolAtLocation(arg);
-    for (const d of (modSym ? L.checker.declarationsOf(modSym) : [])) {
+    const modSym = lowerer.checker.getSymbolAtLocation(arg);
+    for (const d of (modSym ? lowerer.checker.declarationsOf(modSym) : [])) {
         if (ts.isSourceFile(d) && !d.isDeclarationFile) {
             dep = d;
             break;
         }
     }
     if (dep !== null && (dep.fileName.endsWith(".cts") || isCjsJsFile(dep))) {
-        L.unsupported("SC1090", call, `dynamic import of the program's own CommonJS module '${arg.text}' ` +
+        lowerer.unsupported("SC1090", call, `dynamic import of the program's own CommonJS module '${arg.text}' ` +
             "(its namespace comes from module.exports through Node's CJS lexer, " +
             "which has no compiled story — require it, or import it statically)");
     }
-    const builder = dep !== null ? dynNsBuilderOf(L, dep, loc) : null;
+    const builder = dep !== null ? dynNsBuilderOf(lowerer, dep, loc) : null;
     if (builder === null) {
-        L.unsupported("SC1090", call, `dynamic import of the program's own module '${arg.text}' ` +
+        lowerer.unsupported("SC1090", call, `dynamic import of the program's own module '${arg.text}' ` +
             "(this module is not part of the compiled module graph — import it statically)");
     }
     const promiseCtor = { kind: "jsOp", op: "globalGet", name: "Promise", args: [], type: JSVAL, loc };
     const resolved = { kind: "jsOp", op: "callMethod", name: "resolve", args: [promiseCtor], type: JSVAL, loc };
-    const builderAsync = dep !== null && L.asyncInitFiles.has(dep);
+    const builderAsync = dep !== null && lowerer.asyncInitFiles.has(dep);
     const builderFn = {
         kind: "func",
         params: [],
@@ -2261,20 +2190,20 @@ function lowerOwnModuleImport(L, call, arg) {
    * then `return { <sorted exports> }` as an engine object. Null when the
    * module never joined the compiled graph (no %init exists — an empty
    * preflight order or a cycle the extension refused). */
-function dynNsBuilderOf(L, dep, loc) {
-    const cached = L.dynNsBuilders.get(dep);
+function dynNsBuilderOf(lowerer, dep, loc) {
+    const cached = lowerer.dynNsBuilders.get(dep);
     if (cached !== undefined)
         return cached;
-    const initName = L.initNameOf.get(dep);
+    const initName = lowerer.initNameOf.get(dep);
     if (initName === undefined)
         return null;
-    const rawTag = L.fileTag.get(dep) ?? "";
+    const rawTag = lowerer.fileTag.get(dep) ?? "";
     const name = `%dynns.${rawTag === "" ? "e." : rawTag.replace(/^%/, "")}`;
-    L.dynNsBuilders.set(dep, name);
-    const isAsync = L.asyncInitFiles.has(dep);
+    lowerer.dynNsBuilders.set(dep, name);
+    const isAsync = lowerer.asyncInitFiles.has(dep);
     const fnCtx = newFnCtx(true, null, null, JSVAL);
     fnCtx.isAsync = isAsync;
-    L.fnStack.push(fnCtx);
+    lowerer.fnStack.push(fnCtx);
     try {
         const body = [];
         // A synchronous entry has no run-once guard, so its historical
@@ -2283,7 +2212,7 @@ function dynNsBuilderOf(L, dep, loc) {
         // promise is essential for top-level `await import("./self")`,
         // which deadlocks (and ultimately exits 13) in Node rather than
         // exposing a half-evaluated namespace.
-        if (dep !== L.entry || isAsync) {
+        if (dep !== lowerer.entry || isAsync) {
             const call = {
                 kind: "call",
                 callee: initName,
@@ -2291,7 +2220,7 @@ function dynNsBuilderOf(L, dep, loc) {
                 type: isAsync ? { kind: "promise", inner: VOID } : VOID,
                 loc,
             };
-            const cyclePromiseId = L.asyncCyclePromiseOf.get(dep);
+            const cyclePromiseId = lowerer.asyncCyclePromiseOf.get(dep);
             if (isAsync && cyclePromiseId !== undefined) {
                 // Starting the REQUESTED member matters for dynamically-only
                 // cycles: build-time discovery may have encountered another
@@ -2326,7 +2255,7 @@ function dynNsBuilderOf(L, dep, loc) {
         // Node sorts module-namespace keys (code-unit order); tsc erases
         // type-only exports, so only VALUE exports appear.
         const entries = [];
-        const modSym = L.checker.getSymbolAtLocation(dep);
+        const modSym = lowerer.checker.getSymbolAtLocation(dep);
         modSym?.getExports().forEach((sym, key) => {
             const n = String(key);
             if (!n.startsWith("__") && n !== "export=")
@@ -2335,14 +2264,14 @@ function dynNsBuilderOf(L, dep, loc) {
         entries.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
         const args = [];
         for (const [exportName, sym] of entries) {
-            const value = exportJsvalValue(L, exportName, sym, loc);
+            const value = exportJsvalValue(lowerer, exportName, sym, loc);
             if (value === null)
                 continue;
             args.push({ kind: "jsMarshal", value: { kind: "strLit", value: exportName, type: STRING, loc }, type: JSVAL, loc }, value);
         }
         body.push({ kind: "return", value: { kind: "jsOp", op: "objLit", args, type: JSVAL, loc }, loc });
-        const ctx = L.ctx;
-        L.liftedFns.push({
+        const ctx = lowerer.ctx;
+        lowerer.liftedFns.push({
             name,
             params: [],
             returnType: JSVAL,
@@ -2354,7 +2283,7 @@ function dynNsBuilderOf(L, dep, loc) {
         });
     }
     finally {
-        L.fnStack.pop();
+        lowerer.fnStack.pop();
     }
     return name;
 }
@@ -2366,12 +2295,12 @@ function dynNsBuilderOf(L, dep, loc) {
    * called or constructed — the namespace still builds (Node resolves it;
    * only the USE has no compiled story). Null for exports that do not exist
    * at runtime (type-only). */
-function exportJsvalValue(L, name, sym, loc) {
-    const trap = (what) => islandTrapFnValue(L, `the '${name}' export is ${what} of the compiled program, which cannot cross into dynamically-executed code yet`, loc);
+function exportJsvalValue(lowerer, name, sym, loc) {
+    const trap = (what) => islandTrapFnValue(lowerer, `the '${name}' export is ${what} of the compiled program, which cannot cross into dynamically-executed code yet`, loc);
     let resolved = sym;
     if (sym.flags & ts.SymbolFlags.Alias) {
         // `export type { x }` / `export { type x }`: erased at runtime.
-        for (const d of L.checker.declarationsOf(sym)) {
+        for (const d of lowerer.checker.declarationsOf(sym)) {
             if (ts.isExportSpecifier(d)) {
                 const exportDecl = d.parent.parent;
                 if (d.isTypeOnly || (ts.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly))
@@ -2383,11 +2312,11 @@ function exportJsvalValue(L, name, sym, loc) {
                     return null;
             }
         }
-        resolved = L.checker.getAliasedSymbol(sym);
+        resolved = lowerer.checker.getAliasedSymbol(sym);
     }
     if (!(resolved.flags & ts.SymbolFlags.Value))
         return null; // pure type surface
-    const g = L.globalsBySymbol.get(resolved);
+    const g = lowerer.globalsBySymbol.get(resolved);
     if (g) {
         const ref = { kind: "varRef", localId: g.id, type: g.type, loc };
         if (ref.type.kind === "jsval")
@@ -2396,18 +2325,18 @@ function exportJsvalValue(L, name, sym, loc) {
             return { kind: "jsOp", op: ref.type.kind === "undefinedT" ? "undefLit" : "nullLit", args: [], type: JSVAL, loc };
         }
         if (ref.type.kind === "func") {
-            return canMarshalTypedFuncIntoIsland(ref.type, (id) => L.shapes.get(id), (id) => L.unions.get(id))
+            return canMarshalTypedFuncIntoIsland(ref.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))
                 ? { kind: "jsMarshal", value: ref, type: JSVAL, loc }
-                : trap(`a function value of type '${L.fmt(ref.type)}'`);
+                : trap(`a function value of type '${lowerer.fmt(ref.type)}'`);
         }
-        if (L.boundarySafe(ref.type))
+        if (lowerer.boundarySafe(ref.type))
             return { kind: "jsMarshal", value: ref, type: JSVAL, loc };
-        if (L.jsvalLiftable(ref.type))
-            return L.jsvalLiftExpr(ref, loc);
-        return trap(`a value of type '${L.fmt(ref.type)}'`);
+        if (lowerer.jsvalLiftable(ref.type))
+            return lowerer.jsvalLiftExpr(ref, loc);
+        return trap(`a value of type '${lowerer.fmt(ref.type)}'`);
     }
-    const sig = L.fnSigsBySymbol.get(resolved);
-    const decl0 = L.checker.declarationsOf(resolved).find((d) => ts.isFunctionDeclaration(d) && (ts.isSourceFile(d.parent) || L.nsBlocks.get(d.parent) === "flattened"));
+    const sig = lowerer.fnSigsBySymbol.get(resolved);
+    const decl0 = lowerer.checker.declarationsOf(resolved).find((d) => ts.isFunctionDeclaration(d) && (ts.isSourceFile(d.parent) || lowerer.nsBlocks.get(d.parent) === "flattened"));
     if (sig && decl0) {
         if (!sig.params.every((p) => p.mode === "required")) {
             return trap("a function with optional, default, or rest parameters");
@@ -2417,10 +2346,10 @@ function exportJsvalValue(L, name, sym, loc) {
             params: sig.params.map((p) => p.type),
             ret: sig.returnType,
         };
-        if (!canMarshalTypedFuncIntoIsland(funcType, (id) => L.shapes.get(id), (id) => L.unions.get(id))) {
-            return trap(`a function of type '${L.fmt(funcType)}'`);
+        if (!canMarshalTypedFuncIntoIsland(funcType, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+            return trap(`a function of type '${lowerer.fmt(funcType)}'`);
         }
-        L.noteEdge(sig.name);
+        lowerer.noteEdge(sig.name);
         return {
             kind: "jsMarshal",
             value: { kind: "closure", fnName: sig.name, captures: [], type: funcType, loc },
@@ -2428,7 +2357,7 @@ function exportJsvalValue(L, name, sym, loc) {
             loc,
         };
     }
-    if (L.genericFnsBySymbol.has(resolved))
+    if (lowerer.genericFnsBySymbol.has(resolved))
         return trap("a generic function");
     const flags = resolved.flags;
     if (flags & ts.SymbolFlags.Class)
@@ -2445,8 +2374,8 @@ function exportJsvalValue(L, name, sym, loc) {
    * namespace holds the value too), property probes answer like a
    * function's, and calling or `new`-ing it runs the body, which throws
    * the pointed TypeError. */
-function islandTrapFnValue(L, message, loc) {
-    void L;
+function islandTrapFnValue(lowerer, message, loc) {
+    void lowerer;
     const code = `throw new TypeError(${JSON.stringify(message)})`;
     return {
         kind: "jsOp",
@@ -2469,7 +2398,7 @@ function islandTrapFnValue(L, message, loc) {
    * are admitted; engine property names have no identifier restriction. Plain
    * spreads copy through the engine's CopyDataProperties operation in
    * source order, including nested RequestInit/header dictionaries. */
-export function lowerIslandObjectLiteral(L, expr) {
+function lowerIslandObjectLiteral(lowerer, expr) {
     const loc = locOf(expr);
     let args = [];
     let acc = null;
@@ -2486,8 +2415,8 @@ export function lowerIslandObjectLiteral(L, expr) {
         if (ts.isSpreadAssignment(prop)) {
             flushFields();
             const spread = ts.isObjectLiteralExpression(prop.expression)
-                ? lowerIslandObjectLiteral(L, prop.expression)
-                : L.jsvalIn(L.lowerExpr(prop.expression), prop.expression);
+                ? lowerIslandObjectLiteral(lowerer, prop.expression)
+                : lowerer.jsvalIn(lowerer.lowerExpr(prop.expression), prop.expression);
             acc ??= { kind: "jsOp", op: "objLit", args: [], type: JSVAL, loc };
             acc = { kind: "jsOp", op: "objSpread", args: [acc, spread], type: JSVAL, loc: locOf(prop) };
             continue;
@@ -2495,11 +2424,11 @@ export function lowerIslandObjectLiteral(L, expr) {
         if (!ts.isPropertyAssignment(prop) &&
             !ts.isShorthandPropertyAssignment(prop) &&
             !ts.isMethodDeclaration(prop)) {
-            L.unsupported("SC1090", prop, "this property form in an island-built object literal (use a spelled or pure const-folded key with a value or method)");
+            lowerer.unsupported("SC1090", prop, "this property form in an island-built object literal (use a spelled or pure const-folded key with a value or method)");
         }
-        const propertyName = requestInitLiteralKey(L, prop);
+        const propertyName = requestInitLiteralKey(lowerer, prop);
         if (propertyName === null) {
-            L.unsupported("SC1090", prop, "this property key in an island-built object literal (use a spelled or pure const-folded key)");
+            lowerer.unsupported("SC1090", prop, "this property key in an island-built object literal (use a spelled or pure const-folded key)");
         }
         const nameLoc = locOf(prop.name);
         args.push({
@@ -2513,18 +2442,18 @@ export function lowerIslandObjectLiteral(L, expr) {
                 ? prop.name
                 : prop;
         if (ts.isObjectLiteralExpression(valueNode)) {
-            args.push(lowerIslandObjectLiteral(L, valueNode));
+            args.push(lowerIslandObjectLiteral(lowerer, valueNode));
         }
         else if (ts.isArrayLiteralExpression(valueNode) &&
             !valueNode.elements.some(ts.isSpreadElement)) {
-            const elems = valueNode.elements.map((el) => L.jsvalIn(L.lowerExpr(el), el));
+            const elems = valueNode.elements.map((el) => lowerer.jsvalIn(lowerer.lowerExpr(el), el));
             args.push({ kind: "jsOp", op: "arrLit", args: elems, type: JSVAL, loc: locOf(valueNode) });
         }
         else {
             const value = ts.isMethodDeclaration(valueNode)
-                ? (L.rejectThisInObjectMethod(valueNode.body ?? valueNode), L.lowerLambda(valueNode))
-                : L.lowerExpr(valueNode);
-            args.push(L.jsvalIn(value, valueNode));
+                ? (lowerer.rejectThisInObjectMethod(valueNode.body ?? valueNode), lowerer.lowerLambda(valueNode))
+                : lowerer.lowerExpr(valueNode);
+            args.push(lowerer.jsvalIn(value, valueNode));
         }
     }
     flushFields();
@@ -2540,13 +2469,13 @@ export function lowerIslandObjectLiteral(L, expr) {
    * receiver, arity, and argument types against ambient/scriptc.d.ts; an
    * ambient member missing from ISLAND_SURFACE returns null into the
    * existing generic rejections. */
-export function lowerIslandMethodCall(L, call, access) {
-    if (L.chainBlocked(access, call))
+export function lowerIslandMethodCall(lowerer, call, access) {
+    if (lowerer.chainBlocked(access, call))
         return null;
     const name = access.name.text;
     const loc = locOf(call);
     const finish = (receiver, entry) => {
-        const args = call.arguments.map((a) => L.jsvalIn(L.lowerExpr(a), a));
+        const args = call.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
         const result = {
             kind: "jsOp", op: "callMethod", name, args: [receiver, ...args], type: JSVAL, loc,
         };
@@ -2559,11 +2488,11 @@ export function lowerIslandMethodCall(L, call, access) {
     // RequestInit literal into fetch without a JSON detour. The prelude
     // implements all three statics.
     {
-        const sigMember = L.stdlibGlobalMember(access, "AbortSignal");
+        const sigMember = lowerer.stdlibGlobalMember(access, "AbortSignal");
         if ((sigMember === "timeout" || sigMember === "abort" || sigMember === "any") &&
             call.arguments.every((argument) => !ts.isSpreadElement(argument))) {
-            L.requireDynamicApi(`'AbortSignal.${sigMember}'`, call);
-            const args = call.arguments.map((a) => L.jsvalIn(L.lowerExpr(a), a));
+            lowerer.requireDynamicApi(`'AbortSignal.${sigMember}'`, call);
+            const args = call.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
             const signalGlobal = {
                 kind: "jsOp", op: "globalGet", name: "AbortSignal", args: [], type: JSVAL, loc,
             };
@@ -2573,9 +2502,9 @@ export function lowerIslandMethodCall(L, call, access) {
             };
         }
     }
-    if (L.stdlibGlobalMember(access, "ReadableStream") === "from" &&
+    if (lowerer.stdlibGlobalMember(access, "ReadableStream") === "from" &&
         call.arguments.every((argument) => !ts.isSpreadElement(argument))) {
-        L.requireDynamicApi("'ReadableStream.from'", call);
+        lowerer.requireDynamicApi("'ReadableStream.from'", call);
         const streamGlobal = {
             kind: "jsOp",
             op: "globalGet",
@@ -2590,13 +2519,13 @@ export function lowerIslandMethodCall(L, call, access) {
             name: "from",
             args: [
                 streamGlobal,
-                ...call.arguments.map((argument) => L.jsvalIn(L.lowerExpr(argument), argument)),
+                ...call.arguments.map((argument) => lowerer.jsvalIn(lowerer.lowerExpr(argument), argument)),
             ],
             type: JSVAL,
             loc,
         };
     }
-    const isMath = L.stdlibGlobalMember(access, "Math") !== null;
+    const isMath = lowerer.stdlibGlobalMember(access, "Math") !== null;
     // The STATIC Math members (floor/min/max/random): one C call IS the
     // JS operation — no island, no --dynamic. Only the tabled arity with
     // plain (non-spread) arguments takes this path; other forms fall
@@ -2617,7 +2546,7 @@ export function lowerIslandMethodCall(L, call, access) {
             if (call.arguments.length === 0) {
                 return { kind: "numLit", value: name === "max" ? -Infinity : Infinity, type: F64, loc };
             }
-            const args = call.arguments.map((a) => L.lowerExprExpecting(a, F64));
+            const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64));
             let acc = args[0];
             for (let i = 1; i < args.length; i++) {
                 acc = { kind: "libCall", fn: staticMath.fn, args: [acc, args[i]], type: F64, loc };
@@ -2625,7 +2554,7 @@ export function lowerIslandMethodCall(L, call, access) {
             return acc;
         }
         if (call.arguments.length === staticMath.arity) {
-            const args = call.arguments.map((a) => L.lowerExprExpecting(a, F64));
+            const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64));
             return { kind: "libCall", fn: staticMath.fn, args, type: F64, loc };
         }
     }
@@ -2640,9 +2569,9 @@ export function lowerIslandMethodCall(L, call, access) {
         call.arguments.length === 1 &&
         ts.isSpreadElement(call.arguments[0])) {
         const spread = call.arguments[0];
-        const src = L.lowerExpr(spread.expression);
+        const src = lowerer.lowerExpr(spread.expression);
         if (src.type.kind !== "array" || src.type.elem.kind !== "f64") {
-            L.unsupported("SC1090", spread, `spreading '${L.fmt(src.type)}' into Math.${name} (only a number[] spreads)`);
+            lowerer.unsupported("SC1090", spread, `spreading '${lowerer.fmt(src.type)}' into Math.${name} (only a number[] spreads)`);
         }
         return {
             kind: "libCall",
@@ -2654,10 +2583,10 @@ export function lowerIslandMethodCall(L, call, access) {
     }
     const mathFn = isMath ? own(ISLAND_SURFACE.math.fns, name) : undefined;
     if (mathFn && call.arguments.length === mathFn.args.length) {
-        L.requireDynamicApi(`'Math.${name}'`, call);
+        lowerer.requireDynamicApi(`'Math.${name}'`, call);
         return finish({ kind: "jsOp", op: "globalGet", name: "Math", args: [], type: JSVAL, loc }, mathFn);
     }
-    const kind = L.mapTypeOf(L.typeOf(access.expression))?.kind;
+    const kind = lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind;
     const entry = kind === "f64"
         ? own(ISLAND_SURFACE.number, name)
         : kind === "string"
@@ -2665,30 +2594,35 @@ export function lowerIslandMethodCall(L, call, access) {
             : undefined;
     if (!entry || call.arguments.length !== entry.args.length)
         return null;
-    if (!L.isStdlibMember(access))
+    if (!lowerer.isStdlibMember(access))
         return null;
-    L.requireDynamicApi(`'.${name}()' on ${kind === "f64" ? "numbers" : "strings"}`, call);
-    return finish(L.jsvalIn(L.lowerExpr(access.expression), access.expression), entry);
+    lowerer.requireDynamicApi(`'.${name}()' on ${kind === "f64" ? "numbers" : "strings"}`, call);
+    return finish(lowerer.jsvalIn(lowerer.lowerExpr(access.expression), access.expression), entry);
 }
-/** `Math.PI` / `Math.E` property READS: getProp off globalGet("Math"),
-   * exiting to the declared number type. Math methods referenced without a
-   * call are rejected specifically (no value form exists, --dynamic or
-   * not). Null for non-Math receivers (the property chain keeps trying). */
-export function lowerMathProperty(L, expr) {
-    const member = L.stdlibGlobalMember(expr, "Math");
+/** Canonical `Math.PI` / `Math.E` property reads become typed numeric
+   * literals. Remaining Math properties retain the island/fence path. Math
+   * methods referenced without a call are rejected specifically (no value form
+   * exists, --dynamic or not). Null for non-Math receivers (the property chain
+   * keeps trying). */
+export function lowerMathProperty(lowerer, expr) {
+    const member = lowerer.stdlibGlobalMember(expr, "Math");
     if (member === null)
         return null;
     const loc = locOf(expr);
+    const staticValue = own(STATIC_MATH_PROPS, member);
+    if (staticValue !== undefined) {
+        return { kind: "numLit", value: staticValue, type: F64, loc };
+    }
     const propType = own(ISLAND_SURFACE.math.props, member);
     if (propType !== undefined) {
-        L.requireDynamicApi(`'Math.${member}'`, expr);
+        lowerer.requireDynamicApi(`'Math.${member}'`, expr);
         const math = { kind: "jsOp", op: "globalGet", name: "Math", args: [], type: JSVAL, loc };
         const read = { kind: "jsOp", op: "getProp", name: member, args: [math], type: JSVAL, loc };
         return { kind: "jsExit", value: read, type: propType, loc };
     }
     if (own(ISLAND_SURFACE.math.fns, member) !== undefined ||
         own(STATIC_MATH_FNS, member) !== undefined) {
-        L.unsupported("SC1090", expr, `Math methods as values (call '${member}' directly)`);
+        lowerer.unsupported("SC1090", expr, `Math methods as values (call '${member}' directly)`);
     }
     return null; // declared-but-untabled members fall through generically
 }
@@ -2696,13 +2630,13 @@ export function lowerMathProperty(L, expr) {
    * or null when the type isn't package-declared. Union parts are searched
    * too: `string | Command` fails mapping as a whole, but the blame (and
    * the --dynamic attribution) belongs to the package-declared part. */
-export function npmPackageOf(L, type) {
-    const pkg = L.npmPackageOfSymbol(type.getAliasSymbol() ?? type.getSymbol());
+export function npmPackageOf(lowerer, type) {
+    const pkg = lowerer.npmPackageOfSymbol(type.getAliasSymbol() ?? type.getSymbol());
     if (pkg)
         return pkg;
     if (type.isUnionType()) {
         for (const part of ts.constituentTypes(type)) {
-            const partPkg = L.npmPackageOf(part);
+            const partPkg = lowerer.npmPackageOf(part);
             if (partPkg)
                 return partPkg;
         }
@@ -2715,24 +2649,24 @@ export function npmPackageOf(L, type) {
    * attribute the site to the package instead of the generic property/
    * method rejection. No-op under --dynamic (the island paths claimed
    * these) and for non-package receivers, so callers' fallbacks apply. */
-export function npmMemberFence(L, access) {
-    if (L.dynamic)
+export function npmMemberFence(lowerer, access) {
+    if (lowerer.dynamic)
         return;
-    const pkg = L.npmPackageOf(L.typeOf(access.expression)) ??
-        L.npmPackageOfSymbol(L.checker.getSymbolAtLocation(access.name));
+    const pkg = lowerer.npmPackageOf(lowerer.typeOf(access.expression)) ??
+        lowerer.npmPackageOfSymbol(lowerer.checker.getSymbolAtLocation(access.name));
     if (!pkg)
         return;
-    L.pushDiag(requiresDynamicPackageDiag(pkg, locOf(access)));
+    lowerer.pushDiag(requiresDynamicPackageDiag(pkg, locOf(access)));
     throw new PoisonError();
 }
 /** The npm package a SYMBOL is declared by, or null. The symbol half of
    * npmPackageOf, also asked directly for import-alias bindings (whose
    * aliased symbol is the package's export). */
-export function npmPackageOfSymbol(L, sym) {
-    const decls = sym ? L.checker.declarationsOf(sym) : undefined;
+export function npmPackageOfSymbol(lowerer, sym) {
+    const decls = sym ? lowerer.checker.declarationsOf(sym) : undefined;
     if (!decls || decls.length === 0)
         return null;
-    if (!decls.every((d) => L.isNpmFile(d.getSourceFile())))
+    if (!decls.every((d) => lowerer.isNpmFile(d.getSourceFile())))
         return null;
     return npmPackageNameOf(decls[0].getSourceFile().fileName);
 }