@scriptc/compiler 0.0.35 → 0.1.1

package/dist/frontend/lowering/lower-containers.d.ts

@@ -1,6 +1,6 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import { IrExpr, IrFunction, IrRecordShape, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
+import { IrExpr, IrFunction, IrRecordShape, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 /** Ambient array method calls. `push`/`unshift`/`pop`/`reverse`/
  * `indexOf`/`includes`/`join`
    * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
@@ -8,23 +8,7 @@ import { IrExpr, IrFunction, IrRecordShape, IrStmt, IrType, SrcLoc } from "../..
    * direct call of a synthetic loop function (see lowerArrayHofCall and
    * friends). Null when this isn't an ambient array method call. tsc has
    * already checked arity and argument types against ambient/scriptc.d.ts. */
-export declare function lowerArrayMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `a.map(fn)` / `a.filter(fn)` / `a.forEach(fn)` desugar to a direct
-   * call of a synthetic module function — one per method + element/result
-   * type + callback-arity combination, interned — whose body is a plain
-   * loop over EXISTING IR nodes (varDecl/for/arrayGet/callValue/push/
-   * return). No new IR kinds, no backend or runtime involvement. JS
-   * semantics: the length is read ONCE up front (Array.prototype.map/
-   * filter/forEach cache it — elements appended by the callback are not
-   * visited), elements are read fresh each iteration, callbacks run
-   * left-to-right and receive whatever prefix of (element, index, array)
-   * they declare. */
-export declare function lowerArrayHofCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, method: "map" | "filter" | "forEach", elem: IrType): IrExpr;
-/** Interned synthetic loop function for one (method, elem, fnRet, arity)
-   * combo. Named `%arr.<method>.<n>` ('%' keeps it out of the user
-   * namespace); rides `liftedFns` into the module like a lifted lambda (it
-   * is a plain function — no captures). */
-export declare function arrayHofHelper(L: Lowerer, method: "map" | "filter" | "forEach", elem: IrType, fnRet: IrType, arity: number, loc: SrcLoc): string;
+export declare function lowerArrayMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** READ-ONLY array methods on TUPLE receivers — `t.slice(...)` and
    * `t.map(f)`: a tuple is a fixed-shape record, but these methods never
    * write, so the positions snapshot into a fresh array (the for-of-over-
@@ -34,7 +18,7 @@ export declare function arrayHofHelper(L: Lowerer, method: "map" | "filter" | "f
    * each read wrapped into its arm (exactly the checker's callback
    * parameter type). Null when this isn't a tuple slice/map — writers and
    * the rest of the surface keep their fences. */
-export declare function lowerTupleReadMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerTupleReadMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** An OOB-SAFE indexed read: `xs[i]`
    * answers the interned `elem | undefined` union — the element when `i`
    * is an integer in [0, len), JS's property-miss undefined otherwise —
@@ -44,87 +28,13 @@ export declare function lowerTupleReadMethodCall(L: Lowerer, call: ts.CallExpres
    * fire on working Node idioms; program files keep the documented trap
    * (their annotations can prove bounds). Existing element unions retag
    * into the canonical union with an added undefined arm. */
-export declare function lowerSafeIndexRead(L: Lowerer, arr: IrExpr & {
+export declare function lowerSafeIndexRead(lowerer: Lowerer, arr: IrExpr & {
     type: {
         kind: "array";
     };
 }, index: IrExpr, loc: SrcLoc): IrExpr | null;
 /** Backward-compatible name for the npm-static probe path. */
 export declare const lowerNpmStaticSafeIndexRead: typeof lowerSafeIndexRead;
-/** Interned synthetic function for one (elem, argument-shape) concat —
-   * `%arr.concat.<n>(a, x0, x1, ...)`: a fresh array takes a's elements
-   * (pushSpread), then each argument pushes (element) or spreads (array)
-   * in order; the receiver and array arguments are only READ. Rides
-   * liftedFns like the HOF helpers (a plain function — no captures). */
-export declare function arrayConcatHelper(L: Lowerer, elem: IrType, shape: ("e" | "a")[], loc: SrcLoc): string;
-/** The loop body of one synthetic array HOF, from existing IR nodes:
-   *
-   *   map:     out = []; n = a.length; for (i = 0; i < n; i++) out.push(f(a[i])); return out;
-   *   filter:  out = []; n = a.length; for (...) { v = a[i]; if (f(v)) out.push(v); } return out;
-   *   forEach: n = a.length; for (...) f(a[i]);
-   *
-   * `filter` reads the element once into `v` so the callback and the push
-   * see the same value even if the callback mutates `a[i]` (JS-exact).
-   * `arity` is the callback's declared parameter count (1–3): the loop
-   * passes the index and the receiver itself after the element when the
-   * callback names them, exactly the arguments JS supplies. */
-export declare function buildArrayHofFn(L: Lowerer, name: string, method: "map" | "filter" | "forEach", elem: IrType, fnRet: IrType, arity: number, loc: SrcLoc): IrFunction;
-/** `a.find(f)` / `a.findIndex(f)` / `a.findLast(f)` / `a.findLastIndex(f)`
-   * / `a.some(f)` / `a.every(f)` — the early-return HOFs, same
-   * desugar-to-loop machinery. some/every return bool from a short-circuit
-   * loop; findIndex/findLastIndex return the first matching index or -1
-   * (plain f64 — no union). find/findLast return `T | undefined` — the
-   * checker's own result union —
-   * with the found element wrapped into its arm and the miss producing the
-   * undefined unit arm (for REF elements that arm is the unit instance, the
-   * standard union machinery). The Last pair is the SAME loop walked
-   * backwards (`i = n - 1; i >= 0; i--`), exactly the es2023 spec's
-   * descending index walk. All require a bool-returning callback
-   * (JS's ToBoolean of arbitrary predicate results has no lowering). */
-export declare function lowerArrayFindLikeCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, method: "find" | "findIndex" | "findLast" | "findLastIndex" | "some" | "every", elem: IrType): IrExpr;
-/** `a.flatMap(f)` — map plus a one-level flatten. A callback returning
-   * `U[]` appends the returned array's elements per receiver element; a
-   * callback returning a non-array U doesn't flatten (JS pushes it as-is),
-   * which IS map — those calls share map's interned helper. A union return
-   * mixing array and non-array arms would need a per-value flatten decision
-   * — fenced. */
-export declare function lowerArrayFlatMapCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, elem: IrType): IrExpr;
-/** `a.reduce(f)` / `a.reduce(f, init)` and reduceRight — both declared
-   * forms. The accumulator type is the call's own checked result: U with an
-   * initial value, the element type without one. The callback may declare
-   * any prefix of (acc, element, index, array). Without an initial value an
-   * empty receiver throws Node's exact TypeError at runtime. */
-export declare function lowerArrayReduceCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, method: "reduce" | "reduceRight", elem: IrType): IrExpr;
-/** `a.sort(cmp)` / `a.toSorted(cmp)`, desugared to an interned synthetic
-   * function like the other array HOFs. sort mutates and returns the receiver;
-   * toSorted takes its shallow snapshot INSIDE the helper, after the receiver
-   * and comparator expressions have both been evaluated, then sorts and
-   * returns that copy without touching the receiver. The loop is a
-   * binary-free INSERTION sort: stable (equal-comparing elements keep their
-   * source order, which is what Node's stable TimSort produces for any
-   * consistent comparator) and JS-faithful on the comparator contract — an
-   * element moves left only while cmp(left, v) > 0, so a NaN or 0 result holds
-   * position exactly like the spec's "treat as equal". The SEQUENCE of
-   * comparator calls differs from V8's TimSort (SEMANTICS.md); results are
-   * identical for consistent comparators. The comparator-less form lowers for
-   * STRING elements only — JS's default converts every element to string and
-   * compares UTF-16 units, so the interned synthesized comparator selects the
-   * runtime's code-unit ordering rather than scriptc's documented code-point
-   * relational operators. For numbers that default is the notorious string
-   * sort ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
-   * comparator. */
-export declare function lowerArraySortCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, elem: IrType, arrT: IrType & {
-    kind: "array";
-}): IrExpr;
-/** `a.at(i)` — the es2022 relative-index read. Desugars to an interned
-   * helper over existing IR nodes, ToIntegerOrInfinity-exact: the index
-   * truncates toward zero (floor for non-negatives, mirrored floor for
-   * negatives, NaN → 0), negatives wrap by the length once, and anything
-   * still outside [0, n) answers the undefined arm — never a bounds throw.
-   * The result is the checker's own `T | undefined` union, the find
-   * machinery's wrap rules (an undefined-armed element type passes
-   * through). */
-export declare function lowerArrayAtCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, elem: IrType): IrExpr;
 /** `Array.from({ length: n }, mapfn)` — the counted-generation idiom — on
    * THE stdlib Array global. The source must be an OBJECT LITERAL whose
    * single property is `length` (the shape the idiom always spells; the
@@ -137,16 +47,16 @@ export declare function lowerArrayAtCall(L: Lowerer, call: ts.CallExpression, ac
    * array — Node-exact). Every other Array.from shape (arrays, iterables,
    * no mapper) keeps the fence. Null when the callee isn't an
    * Array-static access. */
-export declare function lowerArrayFromCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerArrayFromCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `Array.from(s)` / `[...s]` on a STRING: the code-point split into a
    * fresh string[], through one interned helper per module. */
-export declare function strCharsCall(L: Lowerer, src: IrExpr, loc: SrcLoc): IrExpr;
+export declare function strCharsCall(lowerer: Lowerer, src: IrExpr, loc: SrcLoc): IrExpr;
 /** Ambient Map method calls. `get`/`set`/`has`/`delete`/`clear` lower to
    * mapIntrinsic; `forEach` desugars to a direct call of a synthetic loop
    * function over the iteration primitives (lowerMapForEachCall). Null when
    * this isn't an ambient Map method call. tsc has already checked arity
    * and argument types against ambient/scriptc.d.ts. */
-export declare function lowerMapMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerMapMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `m.forEach(fn)` desugars to a direct call of a synthetic module
    * function — one per key/value type + callback arity, interned — whose
    * body is an index loop over the map's ITERATION PRIMITIVES: read
@@ -157,7 +67,7 @@ export declare function lowerMapMethodCall(L: Lowerer, call: ts.CallExpression,
    * callback throws. That is JS's live-iteration contract, Node-verified
    * (SEMANTICS.md). The callback receives (value, key) like JS; declaring
    * fewer parameters — (value) or () — is ordinary TS and supported. */
-export declare function lowerMapForEachCall(L: Lowerer, call: ts.CallExpression, receiver: IrExpr, mapT: IrType & {
+export declare function lowerMapForEachCall(lowerer: Lowerer, call: ts.CallExpression, receiver: IrExpr, mapT: IrType & {
     kind: "map";
 }): IrExpr;
 /** The loop body of the Map.forEach desugar, from existing IR nodes:
@@ -172,19 +82,19 @@ export declare function lowerMapForEachCall(L: Lowerer, call: ts.CallExpression,
    * The finally keeps the runtime's iteration depth exact when the callback
    * throws (unwinding runs the finally with the exception pending and
    * propagation resumes — the emitter's standard contract). */
-export declare function buildMapForEachFn(L: Lowerer, name: string, mapT: IrType & {
+export declare function buildMapForEachFn(lowerer: Lowerer, name: string, mapT: IrType & {
     kind: "map";
 }, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
 /** Ambient Set method calls — Map's lowering with the value slot gone.
    * `add`/`has`/`delete`/`clear` lower to setIntrinsic; `forEach` desugars
    * like Map's over the shared iteration primitives. Null when this isn't
    * an ambient Set method call. */
-export declare function lowerSetMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerSetMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `s.forEach(fn)` — Map's desugar shape over the set primitives. JS
    * passes (value, value, set): the second parameter IS the element again,
    * so both one- and two-parameter callbacks receive elem-typed arguments
    * (iterKey read once, passed twice). Same live-iteration bracketing. */
-export declare function lowerSetForEachCall(L: Lowerer, call: ts.CallExpression, receiver: IrExpr, setT: IrType & {
+export declare function lowerSetForEachCall(lowerer: Lowerer, call: ts.CallExpression, receiver: IrExpr, setT: IrType & {
     kind: "set";
 }): IrExpr;
 /** The loop body of the Set.forEach desugar — buildMapForEachFn with
@@ -197,7 +107,7 @@ export declare function lowerSetForEachCall(L: Lowerer, call: ts.CallExpression,
    *     }
    *   } finally { s.iterExit(); }
    */
-export declare function buildSetForEachFn(L: Lowerer, name: string, setT: IrType & {
+export declare function buildSetForEachFn(lowerer: Lowerer, name: string, setT: IrType & {
     kind: "set";
 }, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
 /** Object.groupBy / Map.groupBy (ES2024): group an ARRAY's elements by a
@@ -215,7 +125,7 @@ export declare function buildSetForEachFn(L: Lowerer, name: string, setT: IrType
    * util.inspect's "[Object: null prototype]" prefix (ledgered). Other
    * iterables fence (spread into an array first); Null when the callee
    * isn't the stdlib Object/Map groupBy. */
-export declare function lowerGroupByStaticCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerGroupByStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** The lowered iterator-helper chains: `arr.values()` (the array
    * iterator) through any run of map/filter/take/drop/flatMap into a
    * consuming terminal (toArray/forEach/reduce/some/every/find), FUSED
@@ -232,17 +142,7 @@ export declare function lowerGroupByStaticCall(L: Lowerer, call: ts.CallExpressi
    * contract. Everything else — iterator objects stored in bindings,
    * generator/Set/Map receivers, Iterator.from — keeps the lib fences.
    * Null when the callee isn't a terminal over such a chain. */
-export declare function lowerIteratorHelperCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The ES2025 Set composition methods (union/intersection/difference/
-   * symmetricDifference/isSubsetOf/isSupersetOf/isDisjointFrom): one
-   * set-like argument, desugared to an interned two-set helper loop. Only
-   * a REAL Set argument of the receiver's element type lowers — the
-   * desugar substitutes the builtin has/size for the spec's observable
-   * calls, which is exact for Sets and wrong for anything else (a Map or
-   * a custom { has, size, keys } object fences). */
-export declare function lowerSetCombineCall(L: Lowerer, call: ts.CallExpression, name: string, receiver: IrExpr, setT: IrType & {
-    kind: "set";
-}): IrExpr;
+export declare function lowerIteratorHelperCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `for (const [k, v] of m)` / `for (const e of m)` — for-of over a Map,
    * desugared IN PLACE (the body is user code, so no helper function) over
    * the same iteration primitives as the forEach desugar, with the same
@@ -278,7 +178,7 @@ export type ForOfIterProjection = "keys" | "values" | "entries";
    * and deletes shift, the spec's index-based iterator exactly. No
    * enter/exit bracketing: the pair list compacts immediately (no
    * tombstones), so there is no iteration depth to keep exact. */
-export declare function lowerForOfSearchParams(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, proj?: ForOfIterProjection): IrStmt;
+export declare function lowerForOfSearchParams(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, proj?: ForOfIterProjection): IrStmt;
 /** for-of over an ARRAY/typed-array keys()/entries() projection consumed directly
    * by the head (`for (const [index, line] of lines.entries())` — the
    * dominant formatter idiom): the LIVE index walk — the length re-reads
@@ -291,19 +191,19 @@ export declare function lowerForOfSearchParams(L: Lowerer, stmt: ts.ForOfStateme
    * patterns bind through the checker's own element type — the interned
    * [number, T] tuple record. Stored iterator OBJECTS keep their fence
    * (only the direct for-of position unwraps). */
-export declare function lowerForOfArrayIter(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr & {
+export declare function lowerForOfArrayIter(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr & {
     type: (IrType & {
         kind: "array";
     }) | (IrType & {
         kind: "bytes";
     });
 }, proj: "keys" | "entries"): IrStmt;
-export declare function lowerForOfMap(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, mapT: IrType & {
+export declare function lowerForOfMap(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, mapT: IrType & {
     kind: "map";
 }, proj?: ForOfIterProjection): IrStmt;
 /** `for (const v of s)` — for-of over a Set: the Map desugar with iterKey
    * as the (single) element read; same live-iteration contract. */
-export declare function lowerForOfSet(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, setT: IrType & {
+export declare function lowerForOfSet(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, setT: IrType & {
     kind: "set";
 }, proj?: ForOfIterProjection): IrStmt;
 /** `new Map(entries)` from a tuple-array VALUE — any `[K, V][]`-typed
@@ -314,7 +214,7 @@ export declare function lowerForOfSet(L: Lowerer, stmt: ts.ForOfStatement, itera
    * insertion order and a later duplicate key overwrites while keeping the
    * first occurrence's position (set()'s own contract). Null when the
    * argument isn't a matching tuple array (the caller keeps its fence). */
-export declare function lowerMapSeedArrayNew(L: Lowerer, argNode: ts.Expression, mapT: IrType & {
+export declare function lowerMapSeedArrayNew(lowerer: Lowerer, argNode: ts.Expression, mapT: IrType & {
     kind: "map";
 }): IrExpr | null;
 /** Regex method calls, both directions: `re.test(s)` on a regex receiver,
@@ -323,14 +223,14 @@ export declare function lowerMapSeedArrayNew(L: Lowerer, argNode: ts.Expression,
    * overloads keep their island lowering — the argument's mapped type is
    * what routes here, before lowerIslandMethodCall can claim the name).
    * Null when neither shape matches. */
-export declare function lowerRegexMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, dynReceiver?: () => IrExpr): IrExpr | null;
+export declare function lowerRegexMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, dynReceiver?: () => IrExpr): IrExpr | null;
 /** `s.slice(1, 4)` and friends → strIntrinsic. Null when this isn't an
    * ambient string method call (caller keeps its generic rejection). Missing
    * optional arguments are omitted from `args` — the backend fills the
    * documented defaults; the IR never encodes them (Infinity isn't
    * JSON-safe). tsc has already checked arity and argument types against
    * ambient/scriptc.d.ts. */
-export declare function lowerStringMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, dynReceiver?: () => IrExpr): IrExpr | null;
+export declare function lowerStringMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, dynReceiver?: () => IrExpr): IrExpr | null;
 /** `new Uint8Array(...)` / `new Uint32Array(...)` / `new Float32Array(...)`
    * (stdlib provenance — a user's own class with the name resolves through
    * classBySymbol). Lowered argument shapes: none (empty), a length
@@ -342,7 +242,7 @@ export declare function lowerStringMethodCall(L: Lowerer, call: ts.CallExpressio
    * a number[]-typed value. ArrayBuffer/view forms are fenced: scriptc
    * typed arrays own their storage. Null when this isn't a stdlib
    * typed-array construction. */
-export declare function lowerBytesNew(L: Lowerer, expr: ts.NewExpression, symbol: ts.Symbol | null | undefined): IrExpr | null;
+export declare function lowerBytesNew(lowerer: Lowerer, expr: ts.NewExpression, symbol: ts.Symbol | null | undefined): IrExpr | null;
 /** Method calls on typed-array/Buffer receivers: slice and subarray (BOTH
    * copy — subarray's sharing is the documented divergence), set(src,
    * offset?), and the u8-only Buffer surface: toString(enc?) plus the
@@ -350,19 +250,19 @@ export declare function lowerBytesNew(L: Lowerer, expr: ts.NewExpression, symbol
    * variable-width read/writeUIntLE quartet — BUF_NUM_METHODS). Everything
    * else the lib declares (fill, indexOf, reverse, ...) falls through to
    * the SC2020 member fence. Null when this isn't a bytes method call. */
-export declare function lowerBytesMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerBytesMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** A literal encoding's canonical name, or undefined for a spelling Node
  * does not know — the ladder callers (stream options) turn unknown
  * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
 export declare function knownBufEncoding(name: string): string | undefined;
 /** The literal encoding argument of a Buffer surface, normalized — or a
  * fence when it isn't a literal alias Node knows. */
-export declare function bufEncoding(L: Lowerer, what: string, encNode: ts.Expression): string;
+export declare function bufEncoding(lowerer: Lowerer, what: string, encNode: ts.Expression): string;
 /** The Buffer statics — `Buffer.from(...)`, `Buffer.alloc(n)`,
    * `Buffer.concat(list)`, `Buffer.isBuffer(x)` — on THE stdlib Buffer
    * global (name + provenance; fallback and @types/node alike). Null when
    * the callee isn't a Buffer-static access. */
-export declare function lowerBufferStaticCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerBufferStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `Object.keys/values/entries` over an INDEX-SIGNATURE (overflow-carrying)
    * record shape: declared fields answer first from the compile-time field
    * list (declaration order, undefined-valued fields skipped — exactly the
@@ -375,13 +275,13 @@ export declare function lowerBufferStaticCall(L: Lowerer, call: ts.CallExpressio
    * result element type: identity, an arm-into-union wrap, or (dyn
    * results) the dyn conversion — recordKeyGet's own surfacing rules for
    * the overflow, mirrored statically for declared fields. */
-export declare function lowerObjectIterOverIndexShape(L: Lowerer, call: ts.CallExpression, member: "keys" | "values" | "entries", argIr: IrType & {
+export declare function lowerObjectIterOverIndexShape(lowerer: Lowerer, call: ts.CallExpression, member: "keys" | "values" | "entries", argIr: IrType & {
     kind: "record";
 }, shape: IrRecordShape): IrExpr;
 /** The construction core, receiver/result pre-resolved — `node` anchors
  * the fences. for-in reuses the "keys" arm directly (it iterates exactly
  * the keys Object.keys answers; same intern key, one helper). */
-export declare function objectIterOverIndexShape(L: Lowerer, node: ts.Node, member: "keys" | "values" | "entries", argIr: IrType & {
+export declare function objectIterOverIndexShape(lowerer: Lowerer, node: ts.Node, member: "keys" | "values" | "entries", argIr: IrType & {
     kind: "record";
 }, shape: IrRecordShape, receiver: IrExpr, resultT: IrType & {
     kind: "array";
@@ -396,7 +296,7 @@ export declare function objectIterOverIndexShape(L: Lowerer, node: ts.Node, memb
    * The `as ModelPricing` reshape AFTER it is the width-coercion capture
    * (lowerRecordOvfCaptureHelper). Null when the argument or result shape
    * is outside this (Maps, richer iterables → the SC2020 fence). */
-export declare function lowerObjectFromEntriesCall(L: Lowerer, call: ts.CallExpression, callee: ts.Expression): IrExpr | null;
+export declare function lowerObjectFromEntriesCall(lowerer: Lowerer, call: ts.CallExpression, callee: ts.Expression): IrExpr | null;
 /** Interned `%rec.capture.<n>(s)` — the INDEX-SIGNATURE reshape behind
    * `Object.fromEntries(entries) as ModelPricing` (hybrid→hybrid width
    * coercion) and `const r: Record<string, number> = { a: 1, b: 2 }`
@@ -420,7 +320,7 @@ export declare function lowerObjectFromEntriesCall(L: Lowerer, call: ts.CallExpr
    * a same-named source declared field (the rule that admits REQUIRED
    * declared members) or be optional-flavored (the fresh record's
    * default) and writable at runtime. */
-export declare function lowerRecordOvfCaptureHelper(L: Lowerer, fromId: string, toId: string, loc: SrcLoc): string | null;
+export declare function lowerRecordOvfCaptureHelper(lowerer: Lowerer, fromId: string, toId: string, loc: SrcLoc): string | null;
 /** `Object.assign(target, ...sources)` into an INDEX-SIGNATURE record:
    * the capture helper's keyed-write walk aimed at the EXISTING target —
    * each source's declared fields write in declaration order (unset
@@ -433,7 +333,7 @@ export declare function lowerRecordOvfCaptureHelper(L: Lowerer, fromId: string,
    * the dyn conversion), and tsc's `T & U` result type must collapse back
    * to the target's own record shape (the self-shaped merges init-config
    * patterns spell). */
-export declare function lowerObjectAssignIndexShape(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+export declare function lowerObjectAssignIndexShape(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
 /** One contributor of a pure-index-record MERGE literal: a full spread of
  * an index-signature record, or one explicit key. */
 export type IndexMergeContributor = {
@@ -480,7 +380,7 @@ export type IndexMergeContributor = {
    * JS own-key order. Explicit values arrive pre-coerced to the target's
    * value slot. Null when a spread source is outside that matrix (the
    * caller keeps its fence). */
-export declare function lowerIndexMergeHelper(L: Lowerer, toId: string, contributors: IndexMergeContributor[], loc: SrcLoc): string | null;
+export declare function lowerIndexMergeHelper(lowerer: Lowerer, toId: string, contributors: IndexMergeContributor[], loc: SrcLoc): string | null;
 /** The interned helper flattening an env-shaped record into the
    * [k0, v0, k1, v1, ...] string[] cp.execSync consumes — declared string
    * fields first (undefined-armed absents skipped, the Node-drops-undefined
@@ -488,10 +388,10 @@ export declare function lowerIndexMergeHelper(L: Lowerer, toId: string, contribu
    * source must be a string or a `string | undefined` union whose value arm
    * is a string. Null when the shape carries a non-string field/value slot
    * (the caller fences). */
-export declare function lowerEnvToPairsHelper(L: Lowerer, shapeId: string, loc: SrcLoc): string | null;
+export declare function lowerEnvToPairsHelper(lowerer: Lowerer, shapeId: string, loc: SrcLoc): string | null;
 /** The validated-STRING extraction of a dyn method receiver — the receiver
  * expression the string/regex method lowerings consume. */
-export declare function dynStringReceiver(L: Lowerer, recv: IrExpr, access: ts.PropertyAccessExpression): IrExpr;
+export declare function dynStringReceiver(lowerer: Lowerer, recv: IrExpr, access: ts.PropertyAccessExpression): IrExpr;
 /** `d.filter(pred)` on a dyn receiver: the receiver must BE a dyn array
  * (else the Node-shaped TypeError above); the predicate runs per element
  * over the dyn value, and each SURVIVOR is validated-extracted into the
@@ -502,7 +402,7 @@ export declare function dynStringReceiver(L: Lowerer, recv: IrExpr, access: ts.P
  * way there). The result is a fresh STATIC array of extracted copies —
  * the dyn boundary's marshal-copy stance (SEMANTICS.md). Null when the
  * call shape isn't claimable (the method-call fence stays). */
-export declare function lowerDynArrayFilterCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr): IrExpr | null;
+export declare function lowerDynArrayFilterCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr): IrExpr | null;
 /** `.flatMap(f)` on a dyn ('unknown'/`any[]`-narrowed) receiver where the
    * callback returns a STATIC array (`parsed.flatMap((v) => typeof v ===
    * "string" ? parseTldList(v) : [])` — the tlds-file shape): the checked-dynamic tree
@@ -513,4 +413,4 @@ export declare function lowerDynArrayFilterCall(L: Lowerer, call: ts.CallExpress
    * receivers throw the Node-shaped TypeError. Callbacks returning
    * NON-array values (JS would keep them as single elements) or dynamic
    * results keep the fence — nothing drives them yet. */
-export declare function lowerDynArrayFlatMapCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr): IrExpr | null;
+export declare function lowerDynArrayFlatMapCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr): IrExpr | null;