@scriptc/compiler 0.0.35 → 0.0.36

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

@@ -1,6 +1,6 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
+import { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type ClassInfo } from "./lower-classes.js";
 /** How a parameter participates in CALL-SITE COMPLETION (the frontend
@@ -147,7 +147,7 @@ export interface GenericInstance {
    *   one stranded case, unreachable from the else-branch by construction).
    * - `...xs: T[]`: the ABI type is the array; call sites pack the surplus.
    */
-export declare function paramShape(L: Lowerer, param: ts.ParameterDeclaration): ParamShape;
+export declare function paramShape(lowerer: Lowerer, param: ts.ParameterDeclaration): ParamShape;
 /** ParamShapes for a whole parameter list. */
 /** A `this` PARAMETER declaration (`function f(this: void, x: {}) ...`)
    * — type-world only: tsc types the receiver with it, callers never pass
@@ -155,7 +155,7 @@ export declare function paramShape(L: Lowerer, param: ts.ParameterDeclaration):
    * (paramShapes, declareParams) skip it with this predicate so ABI slots
    * and call completion stay aligned with what JS actually passes. */
 export declare function isThisParameter(param: ts.ParameterDeclaration): boolean;
-export declare function paramShapes(L: Lowerer, params: readonly ts.ParameterDeclaration[]): ParamShape[];
+export declare function paramShapes(lowerer: Lowerer, params: readonly ts.ParameterDeclaration[], signature?: ts.Signature, blameOf?: (param: ts.ParameterDeclaration, index: number) => ts.Node): ParamShape[];
 /** The fences on a defaulted parameter's body type: it becomes the value
    * arm of the synthesized `T | undefined` ABI union, so it must be a valid
    * single arm. func and Set ARE valid here: the ABI union's only test is
@@ -163,7 +163,7 @@ export declare function paramShapes(L: Lowerer, params: readonly ts.ParameterDec
    * is what keeps map/set out of general unions), so `runner: Runner =
    * defaultRunner` and `skip: Set<string> = new Set()` arm like any ref
    * kind — the nullable-callback union shape, built by the compiler. */
-export declare function checkDefaultParamBodyType(L: Lowerer, param: ts.ParameterDeclaration, bodyType: IrType): void;
+export declare function checkDefaultParamBodyType(lowerer: Lowerer, param: ts.ParameterDeclaration, bodyType: IrType): void;
 /** CALL-SITE COMPLETION — the frontend half of the one-signature contract
    * (docs/ir.md): every call lowers to exactly the callee's full ABI
    * parameter list, so backends and the validator stay count-exact and no
@@ -172,7 +172,7 @@ export declare function checkDefaultParamBodyType(L: Lowerer, param: ts.Paramete
    * explicitly-passed `undefined` wraps to — both trigger a default, JS-
    * exact); a rest param packs the surplus args (possibly zero) into one
    * array literal, evaluated in source order at the call site. */
-export declare function completeArgs(L: Lowerer, argNodes: readonly ts.Expression[], shapes: readonly ParamShape[], loc: SrcLoc, blame: ts.Node, 
+export declare function completeArgs(lowerer: Lowerer, argNodes: readonly ts.Expression[], shapes: readonly ParamShape[], loc: SrcLoc, blame: ts.Node, 
 /** Pre-lowered values virtually PREPENDED to the argument list — the
  * tagged-template strings object, which has no ts.Expression to lower
  * (lowerTaggedTemplate builds it). Each rides the same slot-directed
@@ -183,7 +183,7 @@ leading?: readonly IrExpr[]): IrExpr[];
    * unitLit under a unionWrap) — the value every "absent" slot holds: an
    * omitted optional argument, an omitted optional record field. Null when
    * `type` has no undefined arm to wrap into. */
-export declare function wrappedUndefined(L: Lowerer, type: IrType, loc: SrcLoc): IrExpr | null;
+export declare function wrappedUndefined(lowerer: Lowerer, type: IrType, loc: SrcLoc): IrExpr | null;
 /** The synthesized argument for an omitted omittable param: the interned
    * undefined arm of the param's `T | undefined` ABI union, or the checked-dynamic tree
    * undefined for a checked-dynamic param (`bar?: any`). */
@@ -192,8 +192,8 @@ export declare function wrappedUndefined(L: Lowerer, type: IrType, loc: SrcLoc):
    * unions, the dyn undefined for checked-dynamic slots, the engine's own
    * undefined for island slots. Shared by every call-completion loop
    * (direct calls and calls through func-typed values). */
-export declare function omittedArgFor(L: Lowerer, type: IrType, loc: SrcLoc): IrExpr | null;
-export declare function undefinedArgFor(L: Lowerer, type: IrType, loc: SrcLoc, blame: ts.Node): IrExpr;
+export declare function omittedArgFor(lowerer: Lowerer, type: IrType, loc: SrcLoc): IrExpr | null;
+export declare function undefinedArgFor(lowerer: Lowerer, type: IrType, loc: SrcLoc, blame: ts.Node): IrExpr;
 /** DECISION (docs/ir.md): function VALUES keep exact-arity semantics — a
    * func-typed IrType spells one completed signature, so a function whose
    * declaration has optional/default/rest parameters can become a value only
@@ -201,13 +201,13 @@ export declare function undefinedArgFor(L: Lowerer, type: IrType, loc: SrcLoc, b
    * parameters (`x?: T` / `x: T = e` params appear as literal `T | undefined`
    * unions; a rest signature is never spellable without `...`, which func
    * types reject). Direct calls get the full feature. */
-export declare function requireExactArityValue(L: Lowerer, blame: ts.Node, contextual: ts.Expression | null, shapes: readonly ParamShape[], funcType: IrType): void;
+export declare function requireExactArityValue(lowerer: Lowerer, blame: ts.Node, contextual: ts.Expression | null, shapes: readonly ParamShape[], funcType: IrType): void;
 /** The BODY-facing return type of a (possibly async) function: an async
    * body's `return v` fulfills its promise with v, so the body returns the
    * promise's INNER type while call sites keep Promise<T>. The declared
    * type of an async function is always a promise (collectSignature /
    * lowerLambda reject anything else before calling this). */
-export declare function bodyReturnType(L: Lowerer, isAsync: boolean, declared: IrType): IrType;
+export declare function bodyReturnType(lowerer: Lowerer, isAsync: boolean, declared: IrType): IrType;
 /** A union-returning body may complete WITHOUT returning — JS yields
    * undefined then (`(): string | undefined => { if (c) return "x"; }`), so
    * an undefined-armed union return gets a trailing `return <undefined
@@ -222,20 +222,20 @@ export declare function bodyReturnType(L: Lowerer, isAsync: boolean, declared: I
    * statement of their own. The trap satisfies the must-return rule as the
    * dead code it is; it can only fire if the checker's proof was violated,
    * which would be a lowering bug — hence the please-report wording. */
-export declare function appendImplicitUndefinedReturn(L: Lowerer, body: IrStmt[], bodyReturn: IrType, loc: SrcLoc): void;
+export declare function appendImplicitUndefinedReturn(lowerer: Lowerer, body: IrStmt[], bodyReturn: IrType, loc: SrcLoc): void;
 /** A declaration's checker-derived IR return type. The unmappable-type
    * diagnostic points at `blame` (the name for top-level declarations, the
    * whole node for lambda-likes — preserving each caller's historical loc). */
-export declare function declaredReturnType(L: Lowerer, decl: ts.SignatureDeclaration, blame: ts.Node): IrType;
-export declare function collectSignature(L: Lowerer, decl: ts.FunctionDeclaration): void;
-export declare function collectSignatureInner(L: Lowerer, decl: ts.FunctionDeclaration): void;
+export declare function declaredReturnType(lowerer: Lowerer, decl: ts.SignatureDeclaration, blame: ts.Node): IrType;
+export declare function collectSignature(lowerer: Lowerer, decl: ts.FunctionDeclaration): void;
+export declare function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclaration): void;
 /** Registers a top-level generic function. Only the SYNTAX is checked
    * here — parameter/return types mention the type parameters and cannot
    * map yet; the body is lowered per instantiation, on demand (an unused
    * generic function costs nothing, like a C++ template). Called inside
    * collectSignature's poison catch. */
-export declare function collectGenericSignature(L: Lowerer, decl: ts.FunctionDeclaration): void;
-export declare function genericFnOf(L: Lowerer, ident: ts.Identifier): GenericFnInfo | null;
+export declare function collectGenericSignature(lowerer: Lowerer, decl: ts.FunctionDeclaration): void;
+export declare function genericFnOf(lowerer: Lowerer, ident: ts.Identifier): GenericFnInfo | null;
 /** Call of a generic top-level function. The checker already inferred (or
    * was told, via explicit type arguments) the concrete signature —
    * getResolvedSignature returns it with type arguments substituted. The
@@ -243,26 +243,12 @@ export declare function genericFnOf(L: Lowerer, ident: ts.Identifier): GenericFn
    * with a new key queues the body for monomorphic lowering as
    * `<qualifiedName>%<n>`, and every call lowers to a direct `call` of that
    * instance. */
-export declare function lowerGenericCall(L: Lowerer, expr: ts.CallExpression, info: GenericFnInfo): IrExpr;
+export declare function lowerGenericCall(lowerer: Lowerer, expr: ts.CallExpression, info: GenericFnInfo): IrExpr;
 /** The instance a CALL of a generic function-like names: resolved
    * signature → mapped param shapes/return → interned instance. Shared by
    * top-level generic calls, class generic-method calls (the caller
    * prepends the receiver), and object-literal generic-method calls. */
-export declare function genericCallInstance(L: Lowerer, expr: ts.CallExpression, info: GenericFnInfo): GenericInstance;
-/** The one instance table both instantiation routes share: key identity IS
-   * signature identity, so a call (`identity(1)`) and a pinned VALUE
-   * (`const f: (x: number) => number = identity`) reuse one compiled
-   * instance. `makeBindings` runs only for a NEW key (binding inference
-   * costs checker walks). */
-export declare function internGenericInstance(L: Lowerer, blame: ts.Node, info: GenericFnInfo, params: ParamShape[], returnType: IrType, makeBindings: (tsBindings: Map<ts.Symbol, ts.Type>) => Map<ts.Symbol, IrType>, opts?: {
-    extraKey?: string;
-    tsBindings?: Map<ts.Symbol, ts.Type>;
-}): GenericInstance;
-/** The type parameters of `info` declared with a `keyof` CONSTRAINT
-   * (`K extends keyof T`) — the parameters whose bound literal is semantic
-   * (the body's `o[k]` reads the named field), computed once per info from
-   * the declaration's syntax. */
-export declare function keyofConstrainedTypeParams(info: GenericFnInfo): Set<ts.Symbol>;
+export declare function genericCallInstance(lowerer: Lowerer, expr: ts.CallExpression, info: GenericFnInfo): GenericInstance;
 /** Type-parameter symbol → concrete IR type for one instantiation.
    * Explicit type arguments bind directly; the rest come from structurally
    * matching each DECLARED param/return type (which mentions the type
@@ -271,25 +257,13 @@ export declare function keyofConstrainedTypeParams(info: GenericFnInfo): Set<ts.
    * construction. A type parameter left unbound only matters if the body
    * mentions it, where mapType fails and badType names the shape
    * (carrying the instantiation context). */
-export declare function inferTypeParamBindings(L: Lowerer, expr: ts.CallExpression, info: GenericFnInfo, rsig: ts.Signature, tsBindings?: Map<ts.Symbol, ts.Type>): Map<ts.Symbol, IrType>;
-/** Type parameters still unbound after unification take their declared
-   * DEFAULT (`<T = number>`), mapped — the checker already substituted the
-   * default into every resolved signature, so this only fills the bindings
-   * an instance body's mapType consults. */
-export declare function bindDefaultTypeParams(L: Lowerer, typeParams: readonly ts.Symbol[], typeParamDecls: readonly ts.TypeParameterDeclaration[] | undefined, bindings: Map<ts.Symbol, IrType>, tsBindings?: Map<ts.Symbol, ts.Type>): void;
-/** The structural half of binding inference: unify the DECLARED signature
-   * (whose types mention the type parameters) against a TARGET signature
-   * with the substitution applied — a call's resolved signature, or the
-   * completed signature a VALUE reference is pinned to (the contextual
-   * type's one call signature). Mutates `bindings`; already-bound
-   * parameters (explicit type arguments) win. */
-export declare function unifySignatureBindings(L: Lowerer, info: GenericFnInfo, rsig: ts.Signature, bindings: Map<ts.Symbol, IrType>, tsBindings?: Map<ts.Symbol, ts.Type>): void;
+export declare function inferTypeParamBindings(lowerer: Lowerer, expr: ts.CallExpression, info: GenericFnInfo, rsig: ts.Signature, tsBindings?: Map<ts.Symbol, ts.Type>): Map<ts.Symbol, IrType>;
 /** Lowers ONE monomorphic instance of a generic function: the same body
    * AST, re-lowered with the type parameters bound (threaded into every
    * mapType call via typeParamResolver — the checker keeps reporting the
    * unsubstituted `T`s inside the body). Coverage stats count a base
    * function's statements once: only the FIRST instance contributes. */
-export declare function lowerGenericInstance(L: Lowerer, info: GenericFnInfo, inst: GenericInstance): IrFunction;
+export declare function lowerGenericInstance(lowerer: Lowerer, info: GenericFnInfo, inst: GenericInstance): IrFunction;
 /** A generic function taken as a VALUE, monomorphized by flow. A function
    * value needs ONE concrete signature; tsc pins one at exactly two
    * reference shapes — an instantiation EXPRESSION (`identity<number>`,
@@ -302,7 +276,7 @@ export declare function lowerGenericInstance(L: Lowerer, info: GenericFnInfo, in
    * zero-capture closure — `f === f` holds within an instantiation, the
    * declared-function identity rule. References with no pinning context
    * (the slot keeps `<T>(x: T) => T`) fence by name. */
-export declare function lowerGenericFnValue(L: Lowerer, ref: ts.Expression, info: GenericFnInfo): IrExpr;
+export declare function lowerGenericFnValue(lowerer: Lowerer, ref: ts.Expression, info: GenericFnInfo): IrExpr;
 /** The npm-static gate: implicit-any monomorphization applies to functions
    * DECLARED in an opted-in package's JS files (user JS keeps today's
    * checked-dynamic story until the corpus is re-baselined). */
@@ -312,7 +286,7 @@ export declare function implicitMonoFile(sf: ts.SourceFile): boolean;
    * implicit-any param (identifier-named, no annotation/JSDoc type, not
    * rest/optional/defaulted, never written), null elsewhere. Null overall
    * when nothing qualifies — the declaration keeps today's path. */
-export declare function implicitAnyParamSymbolsOf(L: Lowerer, decl: ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction): (ts.Symbol | null)[] | null;
+export declare function implicitAnyParamSymbolsOf(lowerer: Lowerer, decl: ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction): (ts.Symbol | null)[] | null;
 /** The instance a CALL of an implicit-any function-like names: each
    * bindable implicit param takes the call's WIDENED argument checker type
    * when it maps statically (DYN otherwise — today's slot), typed params
@@ -320,11 +294,7 @@ export declare function implicitAnyParamSymbolsOf(L: Lowerer, decl: ts.FunctionD
    * instantiation key. New keys lower EAGERLY (return inference — see the
    * section comment); a same-key re-demand mid-lowering pins the fallback
    * return type. */
-export declare function implicitCallInstance(L: Lowerer, call: ts.CallExpression, info: GenericFnInfo): GenericInstance;
-/** The all-dyn DEFAULT instance — today's compiled body exactly: what a
-   * VALUE reference of an implicit-any function names (indirect calls
-   * carry no per-site types to bind). */
-export declare function implicitDefaultInstance(L: Lowerer, blame: ts.Node, info: GenericFnInfo): GenericInstance;
+export declare function implicitCallInstance(lowerer: Lowerer, call: ts.CallExpression, info: GenericFnInfo): GenericInstance;
 /** The implicit-any twin of bindingGenericFnNodeOf, for LOCAL and module
    * bindings alike (`const knownBy = (cmd) => [cmd.name()].concat(...)`
    * inside a method body — commander's _registerCommand shape): the
@@ -337,8 +307,8 @@ export declare function implicitDefaultInstance(L: Lowerer, blame: ts.Node, info
    * params, and a body with NO captures — no `this`/`super`, and no
    * reference to a function-scoped declaration outside itself (compiled
    * instances are module functions; module-scope references are fine).
-   * Cached per declaration on L.implicitLocalFns. */
-export declare function implicitLocalFnNodeOf(L: Lowerer, decl: ts.VariableDeclaration): ts.FunctionExpression | ts.ArrowFunction | null;
+   * Cached per declaration on lowerer.implicitLocalFns. */
+export declare function implicitLocalFnNodeOf(lowerer: Lowerer, decl: ts.VariableDeclaration): ts.FunctionExpression | ts.ArrowFunction | null;
 /** Registers (or returns) the GenericFnInfo of a qualifying implicit-any
    * function-value binding — implicitLocalFnNodeOf's companion, the
    * bindingGenericFnInfoOf shape: the info enters genericFnsBySymbol under
@@ -347,14 +317,14 @@ export declare function implicitLocalFnNodeOf(L: Lowerer, decl: ts.VariableDecla
    * declaration statement emits nothing and the binding has no runtime
    * value. The declaration's source position joins the qualified name —
    * two same-named locals in one file stay distinct. */
-export declare function implicitLocalFnInfoOf(L: Lowerer, decl: ts.VariableDeclaration, fnNode: ts.FunctionExpression | ts.ArrowFunction): GenericFnInfo;
+export declare function implicitLocalFnInfoOf(lowerer: Lowerer, decl: ts.VariableDeclaration, fnNode: ts.FunctionExpression | ts.ArrowFunction): GenericFnInfo;
 /** An island call result the .d.ts DECLARES as a primitive exits eagerly
  * to that static type — the member-read rule's call sibling (see the
  * getProp lowering in lower-exprs.ts): primitives copy by value, every
  * static consumer works on the result, and a lying declaration throws the
  * catchable TypeError. Chain-handled forms stay jsval (the optChain's
  * unit path is the engine's undefined). */
-export declare function islandPrimitiveExit(L: Lowerer, call: ts.CallExpression, result: IrExpr): IrExpr;
+export declare function islandPrimitiveExit(lowerer: Lowerer, call: ts.CallExpression, result: IrExpr): IrExpr;
 /** The trailing-argument timer forms — `setTimeout(cb, ms, ...args)`,
    * `setInterval(cb, ms, ...args)`, `setImmediate(cb, ...args)` — invoke
    * the callback WITH those arguments (Node passes them through). The
@@ -363,16 +333,12 @@ export declare function islandPrimitiveExit(L: Lowerer, call: ts.CallExpression,
    * (per-argument checks against the callee's declared signature, extras
    * ignored, a non-function callee throwing the catchable TypeError).
    * Non-boxable callbacks fence. */
-export declare function timerStyleCallback(L: Lowerer, callArgs: readonly ts.Expression[], what: string, loc: SrcLoc): IrExpr;
-/** The timer surface's member names — the ambient globals AND the
-   * node:timers module's exports (one set: Node's timers module re-exports
-   * the globals). */
-export declare const TIMER_MODULE_MEMBERS: ReadonlySet<string>;
+export declare function timerStyleCallback(lowerer: Lowerer, callArgs: readonly ts.Expression[], what: string, loc: SrcLoc): IrExpr;
 /** One timer call by MEMBER NAME — the shared lowering behind the ambient
    * globals, the node:timers named/destructured imports, and the namespace
    * form (`timers.setTimeout(...)`). Null when the member isn't a lowered
    * timer function (the caller's fence machinery takes over). */
-export declare function lowerTimersMemberCall(L: Lowerer, expr: ts.CallExpression, member: string, loc: SrcLoc): IrExpr | null;
+export declare function lowerTimersMemberCall(lowerer: Lowerer, expr: ts.CallExpression, member: string, loc: SrcLoc): IrExpr | null;
 export interface FfiValidationResult {
     diagnostics: ScrDiagnostic[];
     symbolsByName: ReadonlyMap<string, ReadonlySet<ts.Symbol>>;
@@ -384,104 +350,21 @@ export interface FfiValidationResult {
  * must fit the one manifest ABI. Library callbacks additionally exclude
  * standard-library and package declaration files while retaining project
  * declaration files as authored callback surface. */
-export declare function validateFfiImports(L: Lowerer): FfiValidationResult;
+export declare function validateFfiImports(lowerer: Lowerer): FfiValidationResult;
 /** A manifest-bound call of a signature-only ambient declaration. This
  * recognition deliberately runs before ambientUndefVarRootOf: without the
  * manifest the exact same source keeps Node's ReferenceError semantics;
  * with it, only the resolved declaration binding (never a shadowing
  * function with a body) becomes a direct native call. */
-export declare function lowerFfiCall(L: Lowerer, expr: ts.CallExpression): IrExpr | null;
-export declare function lowerCall(L: Lowerer, expr: ts.CallExpression): IrExpr;
-/** The RUNTIME-ARITY spread call — `f(...args)`, the rest-forwarding idiom
-   * (`const f = (...args) => from(...args)`): a spread whose length is a
-   * runtime fact has no home in the compile-time completion, so the call
-   * rides a dynamic boundary instead. Two lanes, picked by the spread
-   * source's tier:
-   *
-   * - CHECKED-DYNAMIC (dyn spread sources — a JS rest binding, a dyn
-   *   value): box the callee (dynFrom; a dyn callee is already boxed),
-   *   convert every argument into dyn, and emit the spread-marked dynCall
-   *   — the emitters build one fresh dyn argument array (spreads flatten
-   *   left-to-right, non-iterables throw V8's TypeError) and apply through
-   *   it; the boxed thunk delivers JS arity exactly. Result dyn, checked
-   *   per use like every any-origin value.
-   * - ISLAND (a jsval spread source — the --dynamic rest binding is the
-   *   engine's own arguments array): marshal the callee in and emit jsOp
-   *   callSpread — the prelude helper's REAL `f(...pre, ...s)`, so
-   *   iterator protocols and the not-iterable TypeError are the engine's
-   *   own. One trailing spread after the fixed arguments is the modeled
-   *   shape (exactly the forwarding idiom).
-   *
-   * Answers null when neither lane fits (typed .ts spreads keep
-   * completeArgs' rest packing and its fences). JS sources only — the
-   * same guard as the over-arity dynCall precedent. */
-export declare function lowerSpreadArgsCall(L: Lowerer, expr: ts.CallExpression, callee: IrExpr, loc: SrcLoc): IrExpr | null;
-/** True when a spread argument lands where the compile-time completion
-   * cannot take it — a FIXED parameter position, or a dynamic rest slot
-   * (dynRest/islandRest, whose packs are built per-argument): the shapes
-   * the runtime-arity lane (lowerSpreadArgsCall) serves. Typed `rest`
-   * slots keep completeArgs' same-element spread packing. */
-export declare function spreadNeedsRuntimeArity(shapes: readonly ParamShape[], argNodes: readonly ts.Expression[]): boolean;
-/** The SHARED prototype names scr_dyn_invoke dispatches at runtime (the
- * subset of DYN_PROTO_METHOD_NAMES with a receiver-kind dispatch): the
- * runtime runs the real method for the receiver's kind, throws Node's
- * is-not-a-function where the kind's prototype lacks the name, and
- * fences LOUDLY on real-but-unimplemented pairs. */
-export declare const DYN_DISPATCH_METHODS: Set<string>;
-export declare function lowerDynDispatchMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr, arrayReceiver: boolean): IrExpr | null;
-/** Radix-free `.toString()` on a PRIMITIVE receiver: numbers take the
-   * STATIC JS-exact number formatter — the same `toString` node templates
-   * and String(n) lower to (Number::toString with radix 10 IS that
-   * conversion, per spec) — booleans the "true"/"false" texts, and strings
-   * the identity read (String.prototype.toString returns `this`). The
-   * explicit-radix number form keeps its island lowering (ISLAND_SURFACE);
-   * null for other receivers, argument shapes, or non-lib members (a
-   * user's own `.toString` takes the ordinary paths). */
-export declare function lowerNumberToStringCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Radix-free `.toString()` on a UNION receiver whose every arm has one
-   * (string identity, JS-exact number/bool texts, and the Buffer arm's
-   * utf8 decode — Node's default encoding): the per-union ToString
-   * helper dispatches on the tag, so `chunk.toString()` over the ngrok
-   * `Buffer | string` listener param needs no narrowing. Unit-armed
-   * unions stay out — `(undefined).toString()` THROWS in JS, and
-   * claiming it here would silently print "undefined" instead. Null for
-   * other receivers/arms (the narrow-first fences stay). */
-export declare function lowerUnionToStringCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `x.toString()` resolving to Object.prototype.toString (stdlib
-   * provenance, zero arguments) on a RECORD or program-class receiver:
-   * the spec's default answer is the constant "[object Object]". Records
-   * carry no method storage at all, and a class receiver folds only when
-   * neither its chain nor ANY subclass declares toString (dynamic
-   * dispatch could reach an override otherwise — and a resolved override
-   * is the USER's symbol, which never lands here). Pure receivers elide
-   * evaluation; effectful ones evaluate through an interned identity
-   * helper so the receiver's effects keep their place. */
-export declare function lowerDefaultToStringCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The remaining PRIMITIVE prototype surface with a static story, in both
-   * member spellings (`x.hasOwnProperty(...)` and `x['hasOwnProperty'](...)`
-   * — JS resolves the two identically, so the element spelling routes here
-   * from lowerCall's element-access hook):
-   *   - `n.toExponential()` and both `n.toFixed()` forms — the static
-   *     runtime formatters (num.toExponential's shortest-mantissa form,
-   *     num.toFixed0's ties-up integer fast path, and num.toFixed's exact
-   *     binary-value rounding for an explicit fractionDigits).
-   *   - `hasOwnProperty(lit)` on number/boolean receivers — the boxes own
-   *     NOTHING, so any key answers false (a compile-time constant; the
-   *     receiver must be effect-free since the constant elides it).
-   *   - `hasOwnProperty(lit)` on string receivers — "length" is true,
-   *     a canonical array index answers `index < s.length` (indices ARE
-   *     own properties of the box, per spec), every other literal false.
-   *   - the element-access spellings of `toString()` (the primitive
-   *     lowering above) and `charAt(i)` — the two the element hook needs
-   *     beyond this file's own claims.
-   * Null elsewhere: non-literal keys, other members, other receivers. */
-export declare function lowerPrimitiveProtoCall(L: Lowerer, call: ts.CallExpression, recv: ts.Expression, name: string, memberSym: ts.Symbol | undefined): IrExpr | null;
+export declare function lowerFfiCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr | null;
+export declare function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr;
+export declare function lowerDynDispatchMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr, arrayReceiver: boolean): IrExpr | null;
 /** Tagged templates `tag\`a${x}b\`` — ES's call: tag(strings, ...values).
    * The strings object is the per-SITE interned cooked array (the
    * templateStrings node: one immortal string[] per occurrence, so the
    * spec's identity contract holds — the same site evaluated twice hands
    * the tag the SAME array; two sites never share). TemplateStringsArray
-   * maps to string[] (types.ts), so the array rides the ordinary
+   * maps to string[] (type-mapper.ts), so the array rides the ordinary
    * slot-directed coercion into whatever the tag's first parameter wants
    * — string[] exactly, an `any` slot through the dyn boundary, a rest
    * pack's first element. `.raw` does not exist on the lowered object:
@@ -496,26 +379,26 @@ export declare function lowerPrimitiveProtoCall(L: Lowerer, call: ts.CallExpress
    * a checked-dynamic value (the dynCall boundary — a non-function tag
    * throws Node's catchable TypeError). Everything else — generic tags,
    * method tags, function-value bindings — fences by name. */
-export declare function lowerTaggedTemplate(L: Lowerer, expr: ts.TaggedTemplateExpression): IrExpr;
+export declare function lowerTaggedTemplate(lowerer: Lowerer, expr: ts.TaggedTemplateExpression): IrExpr;
 /** True when the identifier resolves (through import aliases) to a
    * top-level function declaration of ANY program file (not merely a
    * same-named local shadowing one). Functions declared directly in a
    * FLATTENED namespace block count — splitFiles hoisted them into the
    * same collection lists top-level declarations ride. */
-export declare function isTopLevelFnSymbol(L: Lowerer, ident: ts.Identifier): boolean;
+export declare function isTopLevelFnSymbol(lowerer: Lowerer, ident: ts.Identifier): boolean;
 /** Nested `function name(...) {...}`: lowered as `const name = <lambda>`
    * at the declaration's statement position (JS hoists function declarations
    * to the top of the enclosing function — calling one before this statement
    * is a compile error here, not a silent divergence). Self-references inside
    * the body lower to `selfRef`, not a capture: a box holding its own
    * closure would be an RC cycle. */
-export declare function lowerNestedFunctionDecl(L: Lowerer, stmt: ts.FunctionDeclaration): IrStmt;
+export declare function lowerNestedFunctionDecl(lowerer: Lowerer, stmt: ts.FunctionDeclaration): IrStmt;
 /** Signature checks + param shapes + IR func type for any lambda-like
    * node. The func type's params are the ABI types, so a lambda with
    * optional/default params has the same IR type as one spelling the
    * `T | undefined` unions with required params — exactly the exact-arity
    * value rule (requireExactArityValue decides who may become a value). */
-export declare function lambdaSignature(L: Lowerer, node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): {
+export declare function lambdaSignature(lowerer: Lowerer, node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): {
     shapes: ParamShape[];
     funcType: IrType & {
         kind: "func";
@@ -533,8 +416,8 @@ export declare function bodyReadsArguments(fn: {
 /** Lifts an arrow function / function expression / nested declaration /
    * object-literal shorthand method to a module-level function and yields
    * the `closure` expression creating it. */
-export declare function lowerLambda(L: Lowerer, node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): IrExpr;
-export declare function lowerPromiseMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerLambda(lowerer: Lowerer, node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): IrExpr;
+export declare function lowerPromiseMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** NARROWING `a.filter(...)` — the two callback forms whose result the
    * checker types as a NARROWER array than the receiver:
    *
@@ -552,7 +435,7 @@ export declare function lowerPromiseMethodCall(L: Lowerer, call: ts.CallExpressi
    * synthesized loop; a multi-arm target would need the union-to-union
    * re-tag that doesn't exist (fenced with the annotate-the-callback
    * escape). Null hands non-narrowing filters to the generic HOF path. */
-export declare function lowerFilterNarrowCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerFilterNarrowCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** The interned keys-array helper over a FIXED record shape: a call of a
  * lifted helper whose body pushes each declared field name in first-seen
  * DECLARATION order, skipping fields currently holding the undefined arm
@@ -560,7 +443,7 @@ export declare function lowerFilterNarrowCall(L: Lowerer, call: ts.CallExpressio
  * never made it into the object; SEMANTICS.md 37's rules). ONE
  * construction, interned per shape, shared by Object.keys and for-in —
  * for-in iterates exactly the keys Object.keys answers. */
-export declare function recordKeysArrayCall(L: Lowerer, receiver: IrExpr, argIr: IrType & {
+export declare function recordKeysArrayCall(lowerer: Lowerer, receiver: IrExpr, argIr: IrType & {
     kind: "record";
 }, shape: {
     declaredOrder?: string[];
@@ -569,13 +452,13 @@ export declare function recordKeysArrayCall(L: Lowerer, receiver: IrExpr, argIr:
         type: IrType;
     }[];
 }, loc: SrcLoc): IrExpr;
-export declare function lowerFunction(L: Lowerer, decl: ts.FunctionDeclaration): IrFunction | null;
-export declare function lowerRecordFieldCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerFunction(lowerer: Lowerer, decl: ts.FunctionDeclaration): IrFunction | null;
+export declare function lowerRecordFieldCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** The function-like node behind an object-literal generic-method member:
    * the MethodDeclaration itself (`{ m<T>(x: T) {...} }`) or a generic
    * arrow/function-expression property's initializer (`{ m: <T>(x: T) =>
    * ... }`). Null when the property's declaration isn't that shape. */
-export declare function objLitGenericFnNodeOf(L: Lowerer, propSym: ts.Symbol): {
+export declare function objLitGenericFnNodeOf(lowerer: Lowerer, propSym: ts.Symbol): {
     fnNode: ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction;
     literal: ts.ObjectLiteralExpression;
 } | null;
@@ -586,7 +469,7 @@ export declare function objLitGenericFnNodeOf(L: Lowerer, propSym: ts.Symbol): {
    * async/generator forms keep the method fences. The name is source-
    * position-derived (`%ol<start>.<name>`, qualified per file) —
    * deterministic across the discovery and emit passes. */
-export declare function objLitGenericFnInfoOf(L: Lowerer, blame: ts.Node, name: string, found: {
+export declare function objLitGenericFnInfoOf(lowerer: Lowerer, blame: ts.Node, name: string, found: {
     fnNode: ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction;
     literal: ts.ObjectLiteralExpression;
 }): GenericFnInfo;
@@ -596,26 +479,12 @@ export declare function objLitGenericFnInfoOf(L: Lowerer, blame: ts.Node, name:
    * Sound file-locally for module-scope bindings because ESM import
    * bindings are read-only — no other file can write one. Cached per
    * symbol (the scan walks the whole file once). */
-export declare function bindingNeverReassigned(L: Lowerer, sym: ts.Symbol, decl: ts.Node): boolean;
-/** Strips the value-preserving wrappers off an expression: parens,
-   * non-null assertions, `as`/`satisfies`/angle-bracket casts. What
-   * remains is the expression that actually evaluates. */
-export declare function stripValueWrappers(e: ts.Expression): ts.Expression;
+export declare function bindingNeverReassigned(lowerer: Lowerer, sym: ts.Symbol, decl: ts.Node): boolean;
 /** The nullish unit `e` provably evaluates to: a bare null/undefined
    * literal (assertion-wrapped — `null as any`, `null!`), or a read of a
    * registered NULLISH binding (nullishGenericBindingUnitOf). Null when
    * the value could be anything else. */
-export declare function nullishExprUnitOf(L: Lowerer, e: ts.Expression): "null" | "undefined" | null;
-/** The nullish unit a binding provably holds FOREVER, by VALUE alone: its
-   * initializer is nullish (`const i: I<A & B> = null as any`) and every
-   * write in its declaring file is nullish too (`a = b` where b is
-   * another nullish binding). No type condition — callers add their own
-   * (nullishGenericBindingUnitOf gates the no-storage family on
-   * unmappable types; the generic-method call path rescues its fence with
-   * the value fact alone). Cached per symbol; the pre-seeded null entry
-   * guards probe cycles (mutually-assigned bindings resolve link by link,
-   * declaration order). */
-export declare function nullishValueUnitOf(L: Lowerer, sym: ts.Symbol | null): "null" | "undefined" | null;
+export declare function nullishExprUnitOf(lowerer: Lowerer, e: ts.Expression): "null" | "undefined" | null;
 /** nullishValueUnitOf gated on a declared type that CANNOT hold the
    * value — the NO-STORAGE family: an unmappable type has no other story,
    * and a RECORD-mapped one (`const i: I<A & B> = null as any` — an
@@ -625,7 +494,7 @@ export declare function nullishValueUnitOf(L: Lowerer, sym: ts.Symbol | null): "
    * declaration emits nothing and reads know the value. Null-tolerant
    * mappings (unions with a null/undefined arm, dyn) keep their real
    * storage and every ordinary lowering. */
-export declare function nullishGenericBindingUnitOf(L: Lowerer, sym: ts.Symbol | null): "null" | "undefined" | null;
+export declare function nullishGenericBindingUnitOf(lowerer: Lowerer, sym: ts.Symbol | null): "null" | "undefined" | null;
 /** True when `sym` — a binding whose type has NO static mapping — is DEAD:
    * never read anywhere in the program, not exported through a specifier,
    * declared with no initializer or a side-effect-free one, and written
@@ -635,9 +504,9 @@ export declare function nullishGenericBindingUnitOf(L: Lowerer, sym: ts.Symbol |
    * on a type the program never consumes (`var xs2: typeof Array;`, the
    * write-only `var f2: { <T, U>(x: T, y: U): T }`). TS program files
    * only: JS bindings keep their checked-dynamic fallbacks. Positive
-   * answers register in L.deadBindings (the assignment lowering skips
+   * answers register in lowerer.deadBindings (the assignment lowering skips
    * writes by the same set). */
-export declare function deadUnmappableBinding(L: Lowerer, sym: ts.Symbol | null, decl: ts.VariableDeclaration): boolean;
+export declare function deadUnmappableBinding(lowerer: Lowerer, sym: ts.Symbol | null, decl: ts.VariableDeclaration): boolean;
 /** The generic function-like INITIALIZER behind a binding declaration —
    * `const f = <T>(x: T) => x` or `const f = function g<T>(x: T) {...}`
    * (parens stripped). Null when the declaration isn't that shape; the
@@ -652,7 +521,7 @@ export declare function bindingGenericFnNodeOf(decl: ts.VariableDeclaration): ts
    * bindingGenericFnInfoOf reads the type parameters off the annotation's
    * signature. Null when the shape doesn't match (a concrete annotation, a
    * generic arrow — the syntactic probe's case, an overloaded alias). */
-export declare function bindingContextualGenericFnNodeOf(L: Lowerer, decl: ts.VariableDeclaration): ts.FunctionExpression | ts.ArrowFunction | null;
+export declare function bindingContextualGenericFnNodeOf(lowerer: Lowerer, decl: ts.VariableDeclaration): ts.FunctionExpression | ts.ArrowFunction | null;
 /** The interned GenericFnInfo for one generic arrow/function-expression
    * binding initializer, with the supportability fences applied ONCE per
    * declaration: the binding must sit at module scope (the compiled
@@ -668,7 +537,7 @@ export declare function bindingContextualGenericFnNodeOf(L: Lowerer, decl: ts.Va
    * body, the class-expression rule) — so every genericFnOf consumer
    * (calls, pinned values, instantiation expressions, namespace and CJS
    * member paths) resolves it like a top-level generic declaration. */
-export declare function bindingGenericFnInfoOf(L: Lowerer, decl: ts.VariableDeclaration, fnNode: ts.FunctionExpression | ts.ArrowFunction): GenericFnInfo;
+export declare function bindingGenericFnInfoOf(lowerer: Lowerer, decl: ts.VariableDeclaration, fnNode: ts.FunctionExpression | ts.ArrowFunction): GenericFnInfo;
 /** `const h = id` — a binding ALIASING a generic function (a top-level
    * declaration, a registered generic binding, or another alias — resolved
    * left to right in declaration order). The alias registers the SAME info
@@ -680,7 +549,7 @@ export declare function bindingGenericFnInfoOf(L: Lowerer, decl: ts.VariableDecl
    * pinned VALUE, the existing lowerGenericFnValue story. Null when the
    * shape doesn't match or the target isn't a registered generic; fences
    * (reassignment, var redeclaration) report by name inside. */
-export declare function bindingGenericFnAliasInfoOf(L: Lowerer, decl: ts.VariableDeclaration): GenericFnInfo | null;
+export declare function bindingGenericFnAliasInfoOf(lowerer: Lowerer, decl: ts.VariableDeclaration): GenericFnInfo | null;
 /** Static resolution stands in for the receiver's runtime value, so an
    * object-literal generic-method receiver must provably HOLD the defining
    * literal: a direct read of a binding whose initializer IS that literal
@@ -690,12 +559,11 @@ export declare function bindingGenericFnAliasInfoOf(L: Lowerer, decl: ts.Variabl
    * evaluating it entirely. A reassignable binding could hold a
    * structurally identical literal with a DIFFERENT body, which static
    * resolution would silently miss. */
-export declare function requireObjLitGenericReceiver(L: Lowerer, blame: ts.Node, recvExpr: ts.Expression, literal: ts.ObjectLiteralExpression, name: string): void;
-export declare function lowerObjLitGenericMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function requireObjLitGenericReceiver(lowerer: Lowerer, blame: ts.Node, recvExpr: ts.Expression, literal: ts.ObjectLiteralExpression, name: string): void;
 /** `obj.method(args)` — whole-program devirtualization decides the form:
    * a method some strict subclass of the receiver's STATIC class overrides
    * must dispatch on the dynamic class (`virtualCall`, through the vtable);
    * everything else — standalone classes, non-overridden methods, leaf
    * receivers — stays a direct `call` of the nearest declaration, exactly
    * as before inheritance existed. */
-export declare function lowerObjectMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerObjectMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;