@scriptc/compiler 0.0.35 → 0.0.36

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

@@ -1,8 +1,8 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import { IrClassDef, IrExpr, IrFunction, IrLocal, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
+import { IrClassDef, IrExpr, IrFunction, IrLocal, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 import { type GenericFnInfo, type ParamShape } from "./lower-calls.js";
-import { type EmitOverrideRec } from "./lower-emitter.js";
+import { type EmitOverrideRec } from "./lower-event-emitter.js";
 import { type MixinInstanceInfo } from "./lower-mixins.js";
 export interface ClassInfo {
     def: IrClassDef;
@@ -72,7 +72,7 @@ export interface ClassInfo {
     builtinError?: true;
     /** Runtime-provided node:events EventEmitter: no bodies lower, `new` and
      * super() become emitter.* libCalls, and the whole method surface
-     * (on/emit/...) lowers through lower-emitter.ts over any class rooted
+     * (on/emit/...) lowers through lower-event-emitter.ts over any class rooted
      * here. Subclass structs embed the ScrEmitter prefix. */
     builtinEmitter?: true;
     /** Runtime-provided node:stream class (Readable/Writable/Duplex/
@@ -86,7 +86,7 @@ export interface ClassInfo {
      * EventEmitter member a subclass may re-declare): never in `methods` —
      * emit calls keep routing through the emitter spoke, which lowers the
      * body once per event name as the specialization method `emit:<event>`
-     * (lower-emitter.ts's emit-overrides block has the whole story). */
+     * (lower-event-emitter.ts's emit-overrides block has the whole story). */
     emitOverride?: EmitOverrideRec;
     ctor: ts.ConstructorDeclaration | null;
     /** PARAMETER PROPERTIES (`constructor(public x: number)`), in parameter
@@ -275,17 +275,17 @@ export interface GenericClassInfo {
    * toString reach them through dedicated error.* libCall lowerings, and
    * user classes extend them like any base (the emitted subclass struct
    * embeds ScrError's prefix). */
-export declare function registerBuiltinErrorClasses(L: Lowerer): void;
+export declare function registerBuiltinErrorClasses(lowerer: Lowerer): void;
 /** The runtime-provided node:events EventEmitter as an eagerly-registered
    * ClassInfo (the error-hierarchy story): mapType names `%EventEmitter`
    * the moment an emitter type appears, so the info must exist before any
    * lowering. No decl, no lowerable bodies — `new`/super() reach it
    * through emitter.* libCalls, the method surface lowers through
-   * lower-emitter.ts, and user classes extend it like any base (the
+   * lower-event-emitter.ts, and user classes extend it like any base (the
    * emitted subclass struct embeds ScrEmitter's registry/name prefix —
    * carried by the BACKEND, not by IR fields, so the fields list stays
    * empty and subclass field layout starts right after the prefix). */
-export declare function registerBuiltinEmitterClass(L: Lowerer): void;
+export declare function registerBuiltinEmitterClass(lowerer: Lowerer): void;
 /** The runtime-provided node:stream classes as eagerly-registered
    * ClassInfos (the emitter story): mapType names `%Readable` et al the
    * moment a stream type appears, so the infos must exist before any
@@ -294,7 +294,7 @@ export declare function registerBuiltinEmitterClass(L: Lowerer): void;
    * unchanged; the stream method/property surface lowers through
    * lower-stream.ts. No decl, no lowerable bodies, empty field lists —
    * every instance is runtime-allocated (user `extends` is fenced). */
-export declare function registerBuiltinStreamClasses(L: Lowerer): void;
+export declare function registerBuiltinStreamClasses(lowerer: Lowerer): void;
 /** The stream ClassInfo a VALUE symbol refers to (`new Readable(...)`,
    * `x instanceof Writable`) — any import spelling resolves to the
    * ambient class. Provenance: a stdlib-file CLASS declaration inside the
@@ -302,33 +302,25 @@ export declare function registerBuiltinStreamClasses(L: Lowerer): void;
    * also types child stdio — under @types/node the childStream mapping
    * keeps priority and the static stream classes stand down; the shipped
    * fallback declarations are the supported surface). */
-export declare function builtinStreamInfoOf(L: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
+export declare function builtinStreamInfoOf(lowerer: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
 /** The emitter ClassInfo a VALUE symbol refers to (`new EventEmitter`,
    * `extends EventEmitter`, `x instanceof EventEmitter`) — any import
    * spelling (named/default/namespace member, CJS require) resolves to
    * the ambient class. Provenance-checked like the error classes: only a
    * stdlib-file declaration inside the "events" ambient module counts. */
-export declare function builtinEmitterInfoOf(L: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
+export declare function builtinEmitterInfoOf(lowerer: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
 /** The builtin error ClassInfo a VALUE symbol refers to (`new Error`,
    * `extends TypeError`, `x instanceof RangeError`), or null. Provenance-
    * checked: only the standard library's declarations count — a user's own
    * `class Error` resolves through classBySymbol instead. */
-export declare function builtinErrorInfoOf(L: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
+export declare function builtinErrorInfoOf(lowerer: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
 /** The instance-method surface the runtime EventEmitter owns — subclass
  * members with these names are fenced (collectClassShapeInner) and calls
- * to them on emitter-rooted receivers lower through lower-emitter.ts. */
+ * to them on emitter-rooted receivers lower through lower-event-emitter.ts. */
 export declare const EMITTER_API_MEMBERS: ReadonlySet<string>;
 /** The decorators of a class-like or member node (they live in
    * `modifiers` since TS 4.8). */
 export declare function decoratorNodesOf(n: ts.Node): ts.Decorator[];
-/** The AMBIENT name a decorator expression's evaluation throws on, or
-   * null. Node erases ambient declarations (`declare let dec: any`,
-   * `declare const instance: T`, `declare function dec<T>(t: T): T`), so
-   * reading the name is a ReferenceError. Factory spellings ride along —
-   * `@dec(...)` evaluates the CALLEE before any argument — and property
-   * chains throw at their ROOT (`@instance.decorate` reads `instance`
-   * first). */
-export declare function ambientDecoratorThrowNameOf(L: Lowerer, dExpr: ts.Expression): string | null;
 /** The guaranteed decoration THROW of a decorated class, or null. Walks
    * the class definition's evaluation-order items — class decorators
    * (source order), the heritage expression, then per member in body
@@ -340,12 +332,12 @@ export declare function ambientDecoratorThrowNameOf(L: Lowerer, dExpr: ts.Expres
    * computed keys. Anything richer (factory calls over defined values,
    * property-access reads, computed-key calls) stops the proof — the
    * named fences answer instead. */
-export declare function guaranteedDecorationThrow(L: Lowerer, decl: ts.ClassLikeDeclaration): {
+export declare function guaranteedDecorationThrow(lowerer: Lowerer, decl: ts.ClassLikeDeclaration): {
     name: string;
     node: ts.Decorator;
 } | null;
-export declare function collectClassShape(L: Lowerer, decl: ts.ClassDeclaration): void;
-export declare function collectClassShapeInner(L: Lowerer, decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
+export declare function collectClassShape(lowerer: Lowerer, decl: ts.ClassDeclaration): void;
+export declare function collectClassShapeInner(lowerer: Lowerer, decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
     family: ClassInfo;
     name: string;
     bindings: Map<ts.Symbol, IrType>;
@@ -375,21 +367,14 @@ mixin?: {
    * unmapped, the fenced-JS-class story. Null answers (unmappable type
    * arguments, the instance cap, an uncollected family) make the whole
    * reference unmappable — per-site diagnostics own the fence. */
-export declare function genericClassInstanceType(L: Lowerer, decl: ts.ClassLikeDeclaration, ref: ts.Type): IrType | null;
-/** Runs a member-lowering thunk under an INSTANTIATION's type-parameter
-   * bindings (the generic-fn typeParamResolver mechanism) — the checker
-   * keeps reporting the unsubstituted `T`s inside the shared body AST.
-   * Coverage counts a generic class's statements once: only the FIRST
-   * instantiation contributes (the lowerGenericInstance rule). A no-op
-   * for ordinary classes. */
-export declare function withInstanceBindings<T>(L: Lowerer, info: ClassInfo, fn: () => T): T;
+export declare function genericClassInstanceType(lowerer: Lowerer, decl: ts.ClassLikeDeclaration, ref: ts.Type): IrType | null;
 /** The `%init` statements for one class's static readonly fields AND
    * static blocks, interleaved in member order — emitted at the class
    * statement's source position (see lowerFileInit's merge), exactly when
    * JS evaluates static initializers and blocks. Field failures poison per
    * field, like fieldInitStmts; a block lowers as the block statement it
    * is, so its statements poison individually inside lowerStmts. */
-export declare function lowerStaticFieldInits(L: Lowerer, info: ClassInfo): IrStmt[];
+export declare function lowerStaticFieldInits(lowerer: Lowerer, info: ClassInfo): IrStmt[];
 /** Post-collection analysis of a decorated class (all shapes registered —
    * a decorator's return type may name a subclass declared BELOW the
    * class). Classifies every class-level decorator by its checker type:
@@ -407,22 +392,12 @@ export declare function lowerStaticFieldInits(L: Lowerer, info: ClassInfo): IrSt
    * build time; the runtime base would be the decoration result) and
    * namespace-nested declarations (qualified references resolve the class
    * directly, not through the rebound value). */
-export declare function analyzeClassDecoration(L: Lowerer, info: ClassInfo): void;
-/** The decoration statements of a decorated class — the %init code that
-   * runs at the class statement's position, BEFORE its static field
-   * initializers and blocks (lowerStaticFieldInits composes them; the
-   * lower-modules interleave places the whole bundle). Verified Node
-   * order: decorator expressions evaluate in SOURCE order (factories run
-   * here), then applications run in REVERSE member order over the class
-   * object, each replacing decorator's non-undefined result feeding the
-   * next application; the final value binds the class name (the mutable
-   * classval global) when any decorator can replace. */
-export declare function lowerClassDecoration(L: Lowerer, info: ClassInfo): IrStmt[];
+export declare function analyzeClassDecoration(lowerer: Lowerer, info: ClassInfo): void;
 /** The nearest declaration of static member `name` at or above `info` —
    * the compile-time prototype-chain walk (`D.x` reads C's global when C
    * declared x and nothing between redeclares it; a redeclaration shadows
    * with its OWN storage, exactly JS). */
-export declare function findStaticOn(L: Lowerer, info: ClassInfo | null, name: string): {
+export declare function findStaticOn(lowerer: Lowerer, info: ClassInfo | null, name: string): {
     declarer: ClassInfo;
     field: ClassInfo["staticFields"][number];
     method?: undefined;
@@ -439,10 +414,10 @@ export declare function findStaticOn(L: Lowerer, info: ClassInfo | null, name: s
    * the through-a-VALUE devirtualization test: a classval(info) slot can
    * hold any descendant, and a shadowing redeclaration means the runtime
    * class decides which storage answers. */
-export declare function staticShadowBelow(L: Lowerer, info: ClassInfo, name: string): boolean;
+export declare function staticShadowBelow(lowerer: Lowerer, info: ClassInfo, name: string): boolean;
 /** The nearest GENERIC static declaration of `name` at/above `info` —
    * findStaticOn's twin over the genericStatics tables. */
-export declare function findGenericStaticOn(L: Lowerer, info: ClassInfo | null, name: string): {
+export declare function findGenericStaticOn(lowerer: Lowerer, info: ClassInfo | null, name: string): {
     declarer: ClassInfo;
     info: GenericFnInfo;
 } | null;
@@ -454,20 +429,20 @@ export declare function findGenericStaticOn(L: Lowerer, info: ClassInfo | null,
    * constructor (Error/EventEmitter/stream chains complete their `new`
    * by special rules) — are named fences here. The constructor edge is
    * noted at every classRef: a value can always be constructed through. */
-export declare function classValueRef(L: Lowerer, info: ClassInfo, blame: ts.Node): IrExpr;
+export declare function classValueRef(lowerer: Lowerer, info: ClassInfo, blame: ts.Node): IrExpr;
 /** Constructor-ABI equality — the classval widening rule: a classval(D)
    * value may flow into a classval(C) slot only when D's completed
    * constructor signature equals C's (same count, modes, and ABI types),
    * which is what keeps newValue completion against C's one signature
    * sound for every value legally in the slot. */
-export declare function ctorAbiEquals(L: Lowerer, sub: ClassInfo, sup: ClassInfo): boolean;
+export declare function ctorAbiEquals(lowerer: Lowerer, sub: ClassInfo, sup: ClassInfo): boolean;
 /** `C.x` where C is a class declared in the program and x a static
    * member of its chain: field reads are the module global, static
    * methods become interned closures, and `.name` folds to the class's
    * compile-time name. Null for everything else — unresolved members
    * fall through to the ordinary chain so the static fence or the
    * generic member rejection names the site. */
-export declare function lowerStaticFieldRead(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerStaticFieldRead(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** A class EXPRESSION's ClassInfo: collection on first encounter (the
    * declaration path over the shared ClassLikeDeclaration machinery, with
    * NamedEvaluation supplying the runtime .name), idempotent per node —
@@ -479,7 +454,7 @@ export declare function lowerStaticFieldRead(L: Lowerer, expr: ts.PropertyAccess
    * once. Statics-bearing expressions additionally restrict to positions
    * where "immediately before the enclosing statement" IS the evaluation
    * point (lowerFileInit drains pendingClassExprInits there). */
-export declare function lowerClassExpressionInfo(L: Lowerer, expr: ts.ClassExpression): ClassInfo;
+export declare function lowerClassExpressionInfo(lowerer: Lowerer, expr: ts.ClassExpression): ClassInfo;
 /** `class {…}` in expression position: a class definition bound to no
    * statement — once the static side is a value, the expression IS the
    * definition plus a classRef over it. A DECORATED class expression
@@ -488,14 +463,14 @@ export declare function lowerClassExpressionInfo(L: Lowerer, expr: ts.ClassExpre
    * ReferenceError, so it lowers to exactly that read — every evaluation
    * throws identically, which is why the once-evaluated restriction and
    * the member fences don't apply. */
-export declare function lowerClassExpression(L: Lowerer, expr: ts.ClassExpression): IrExpr;
+export declare function lowerClassExpression(lowerer: Lowerer, expr: ts.ClassExpression): IrExpr;
 /** The EXACT class a receiver expression is statically known to BE (not
    * merely be typed by): the class name itself, or a `const` binding
    * whose initializer is a class expression / class name. Such receivers
    * can never hold a subclass at runtime, so static WRITES through them
    * hit the declaring class's storage exactly (the shadowing hazards of
    * general class values don't arise). Null for everything else. */
-export declare function exactClassOfReceiver(L: Lowerer, expr: ts.Expression): ClassInfo | null;
+export declare function exactClassOfReceiver(lowerer: Lowerer, expr: ts.Expression): ClassInfo | null;
 /** The class a PROPERTY-ASSIGNMENT binding pins — the salsa/CJS
    * declaration forms of a class expression: `Common.I = class {…}`
    * (expando members of a plain object), `exports.I = class {…}` /
@@ -511,7 +486,7 @@ export declare function exactClassOfReceiver(L: Lowerer, expr: ts.Expression): C
    * fence names it. Collection is on demand and idempotent
    * (lowerClassExpressionInfo), so resolution order between files and
    * passes never matters. */
-export declare function propertyAssignedClassInfoOf(L: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
+export declare function propertyAssignedClassInfoOf(lowerer: Lowerer, symbol: ts.Symbol | null | undefined): ClassInfo | null;
 /** `C.m(args)` / `X.m(args)` — static method calls, on the class name
    * directly or through a class VALUE. Resolution walks the chain
    * (nearest declarer, the compile-time prototype chain); through a
@@ -521,7 +496,7 @@ export declare function propertyAssignedClassInfoOf(L: Lowerer, symbol: ts.Symbo
    * global and calls through the value. Null when the receiver isn't a
    * class name/value or the member doesn't resolve (the fences name the
    * site downstream). */
-export declare function lowerStaticMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerStaticMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** Static member access through a class VALUE (`X.m` where X is
    * classval-typed): devirtualized — the member resolves against the
    * static class's chain, exact when no strict descendant redeclares it
@@ -529,10 +504,10 @@ export declare function lowerStaticMethodCall(L: Lowerer, call: ts.CallExpressio
    * genuinely dynamic member: the class.name libCall reads the runtime
    * class object's stored name. Null when the receiver isn't a class
    * value or the member doesn't resolve. */
-export declare function lowerClassValueProperty(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerClassValueProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** The nearest declaration of `name` at or above `info` — the method a
    * receiver of that static class runs when nothing below overrides it. */
-export declare function findMethodOn(L: Lowerer, info: ClassInfo | null, name: string): {
+export declare function findMethodOn(lowerer: Lowerer, info: ClassInfo | null, name: string): {
     declarer: ClassInfo;
     sig: {
         params: ParamShape[];
@@ -546,35 +521,30 @@ export declare function findMethodOn(L: Lowerer, info: ClassInfo | null, name: s
     };
 } | null;
 /** True when `sub` is a STRICT descendant of `sup` in the class graph. */
-export declare function isSubclassOf(L: Lowerer, sub: string, sup: string): boolean;
+export declare function isSubclassOf(lowerer: Lowerer, sub: string, sup: string): boolean;
 /** In an extends-hierarchy (as base or derived): the class carries a
    * vtable and participates in dynamic instanceof; standalone classes keep
    * their exact pre-inheritance layout and behavior. */
-export declare function inHierarchy(L: Lowerer, info: ClassInfo): boolean;
+export declare function inHierarchy(lowerer: Lowerer, info: ClassInfo): boolean;
 /** True when some STRICT descendant of `info` declares `name` with a BODY
    * — the whole-program devirtualization test: a call through this static
    * class can reach a distinct implementation, so it must dispatch
    * dynamically. Abstract re-declarations don't count (they carry no
    * implementation; the concrete ones below them do, via the recursion). */
-export declare function overrideBelow(L: Lowerer, info: ClassInfo, name: string): boolean;
+export declare function overrideBelow(lowerer: Lowerer, info: ClassInfo, name: string): boolean;
 /** The nearest GENERIC-method declaration of `name` at/above `info` —
    * findMethodOn's twin over the genericMethods tables. */
-export declare function findGenericMethodOn(L: Lowerer, info: ClassInfo | null, name: string): {
+export declare function findGenericMethodOn(lowerer: Lowerer, info: ClassInfo | null, name: string): {
     declarer: ClassInfo;
     info: GenericFnInfo;
 } | null;
-/** True when some STRICT descendant of `info` re-declares the generic
-   * method `name` — overrideBelow's twin: generic methods have no vtable
-   * slot, so a call that could reach an override compiles only when the
-   * receiver's runtime class is statically exact. */
-export declare function genericOverrideBelow(L: Lowerer, info: ClassInfo, name: string): boolean;
 /** The receiver's EXACT runtime class, when the expression proves it: a
    * `new C(...)` expression directly, or a const binding initialized with
    * one (the binding can never be reassigned to a subclass instance).
    * The class is read off the mapped INITIALIZER type — a `const b: Base =
    * new D()` receiver is exactly D, not its annotation. Distinct from
    * exactClassOfReceiver, which answers for CLASS-VALUE receivers. */
-export declare function exactInstanceClassOf(L: Lowerer, expr: ts.Expression): ClassInfo | null;
+export declare function exactInstanceClassOf(lowerer: Lowerer, expr: ts.Expression): ClassInfo | null;
 /** `const r: Repo = new MemRepo()` where EVERY member of the annotation's
    * checker type is a generic-callable method (`interface Repo { get<T>(id:
    * string): T }`): the record shape maps EMPTY — generic members are
@@ -587,7 +557,7 @@ export declare function exactInstanceClassOf(L: Lowerer, expr: ts.Expression): C
    * and uses that want the empty record width-coerce at the use site.
    * Const + direct `new` only — a reassignable binding or a produced
    * value keeps today's record story and its fences. */
-export declare function genericIfaceBindingKeepsClass(L: Lowerer, decl: ts.VariableDeclaration, declaredType: IrType): boolean;
+export declare function genericIfaceBindingKeepsClass(lowerer: Lowerer, decl: ts.VariableDeclaration, declaredType: IrType): boolean;
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
    * checker's resolved signature (type arguments substituted, inferred or
    * explicit) keys one instantiation of the nearest declarer's body, and
@@ -596,19 +566,19 @@ export declare function genericIfaceBindingKeepsClass(L: Lowerer, decl: ts.Varia
    * runtime class could OVERRIDE the method (genericOverrideBelow) must be
    * statically exact (exactInstanceClassOf) — the override set then
    * resolves at compile time — or fences by name. */
-export declare function lowerClassGenericMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recvInfo: ClassInfo, found: {
+export declare function lowerClassGenericMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recvInfo: ClassInfo, found: {
     declarer: ClassInfo;
     info: GenericFnInfo;
 }, recvIr?: IrExpr): IrExpr;
 /** Wraps a derived-class expression in an upcast when the target base
    * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
-export declare function upcastTo(L: Lowerer, expr: IrExpr, className: string): IrExpr;
-export declare function lowerClassMembers(L: Lowerer, info: ClassInfo): IrFunction[];
+export declare function upcastTo(lowerer: Lowerer, expr: IrExpr, className: string): IrExpr;
+export declare function lowerClassMembers(lowerer: Lowerer, info: ClassInfo): IrFunction[];
 /** The constructor function `%C.constructor`. Synthesized when absent: a
    * base class runs just its field initializers; a derived class inherits
    * the base's signature — forward every param to super(), then run own
    * field initializers. */
-export declare function lowerClassCtor(L: Lowerer, info: ClassInfo): IrFunction;
+export declare function lowerClassCtor(lowerer: Lowerer, info: ClassInfo): IrFunction;
 /** The lowered method-map name of a class member: identifier text, a
    * COMPUTED name that folds to one compile-time string
    * (foldedStringKeyOf — the object-literal computed-key machinery
@@ -618,7 +588,7 @@ export declare function lowerClassCtor(L: Lowerer, info: ClassInfo): IrFunction;
    * accessor "get:x" convention; for-of, spreads, and array destructuring
    * dispatch to it through the iterator protocol). Null for genuinely
    * runtime-keyed names — the computed-member fences stay. */
-export declare function classMemberNameOf(L: Lowerer, name: ts.PropertyName): string | null;
+export declare function classMemberNameOf(lowerer: Lowerer, name: ts.PropertyName): string | null;
 /** A class type's ITERATOR PROTOCOL shape, statically resolved: the
    * receiver declares (or inherits) `[Symbol.iterator]()` (the
    * "sym:iterator" method slot) returning a class whose zero-parameter
@@ -647,12 +617,12 @@ export interface ClassIteratorInfo {
     /** False: no done field — the protocol never terminates. */
     hasDone: boolean;
 }
-export declare function classIteratorOf(L: Lowerer, t: IrType): ClassIteratorInfo | null;
+export declare function classIteratorOf(lowerer: Lowerer, t: IrType): ClassIteratorInfo | null;
 /** The `it.next()` step of a class iterator as an ordinary (possibly
    * virtual) method call. */
-export declare function classIteratorNextCall(L: Lowerer, cit: ClassIteratorInfo, itRef: IrExpr, loc: SrcLoc): IrExpr;
+export declare function classIteratorNextCall(lowerer: Lowerer, cit: ClassIteratorInfo, itRef: IrExpr, loc: SrcLoc): IrExpr;
 /** `recv[Symbol.iterator]()` as an ordinary method call. */
-export declare function classIteratorOpenCall(L: Lowerer, cit: ClassIteratorInfo, recv: IrExpr, loc: SrcLoc): IrExpr;
+export declare function classIteratorOpenCall(lowerer: Lowerer, cit: ClassIteratorInfo, recv: IrExpr, loc: SrcLoc): IrExpr;
 /** `[...new C]` / `f(...new C)` over a CLASS ITERABLE: the eager drain —
    * an interned `%iter.drain.<n>(recv)` lifted function running the
    * whole protocol into a fresh element array (a doneless iterator loops
@@ -662,15 +632,15 @@ export declare function classIteratorOpenCall(L: Lowerer, cit: ClassIteratorInfo
    * `(number | symbol)[]`) pushes each value wrapped into its arm. Null
    * when the value isn't a recognized class iterable or the element
    * doesn't coerce — spread fences stay. */
-export declare function classIteratorDrainCall(L: Lowerer, src: IrExpr, loc: SrcLoc, elemT?: IrType): IrExpr | null;
+export declare function classIteratorDrainCall(lowerer: Lowerer, src: IrExpr, loc: SrcLoc, elemT?: IrType): IrExpr | null;
 /** The tail of a class iterable's protocol from an already-open ITERATOR
    * object (`var [a, ...rest] = new C` — the rest element drains whatever
    * next() still yields): the drain loop keyed by the iterator class. */
-export declare function classIteratorRestDrainCall(L: Lowerer, cit: ClassIteratorInfo, itVal: IrExpr, loc: SrcLoc): IrExpr;
+export declare function classIteratorRestDrainCall(lowerer: Lowerer, cit: ClassIteratorInfo, itVal: IrExpr, loc: SrcLoc): IrExpr;
 /** One method or accessor body as its module function `%C.name`
    * (accessors are methods with property syntax: "get:x"/"set:x" entries —
    * see collectClassShape). */
-export declare function lowerClassMethodMember(L: Lowerer, info: ClassInfo, fnLike: ts.MethodDeclaration | ts.AccessorDeclaration): IrFunction | null;
+export declare function lowerClassMethodMember(lowerer: Lowerer, info: ClassInfo, fnLike: ts.MethodDeclaration | ts.AccessorDeclaration): IrFunction | null;
 /** One static method body as its module function `%C.static:m` — an
    * ordinary function with NO `this` param. `this` and `super` inside
    * name the RECEIVER class in JS (dynamic — `F.who()` sees F even when
@@ -678,34 +648,17 @@ export declare function lowerClassMethodMember(L: Lowerer, info: ClassInfo, fnLi
    * named fences, with arrow functions transparent (they inherit the
    * method's `this`) and this-binding function forms opaque — the static-
    * block rule verbatim. */
-export declare function lowerStaticMethod(L: Lowerer, info: ClassInfo, name: string): IrFunction | null;
+export declare function lowerStaticMethod(lowerer: Lowerer, info: ClassInfo, name: string): IrFunction | null;
 /** A synthesized throwing setter: a getter-only override shadows the
    * inherited pair (JS), so a base-typed write dispatches HERE and must
    * throw exactly like Node's TypeError — a real instance (a typed catch's
    * `e instanceof TypeError` matches), catchable, exit 1 uncaught (message
    * text is compiler-worded; stdout and exit code are the contract). */
-export declare function throwingSetterFn(L: Lowerer, info: ClassInfo, prop: string): IrFunction;
-/** The base a constructor chain actually CALLS into: generic FAMILIES are
-   * never constructed (no `%<family>.constructor` exists), so an
-   * instantiation's construction-relevant base is the family's own base —
-   * null when the generic class extends nothing, exactly the source's
-   * story (tsc forbids super() there). Ordinary classes answer their base
-   * unchanged. */
-export declare function superBaseOf(info: ClassInfo): ClassInfo | null;
+export declare function throwingSetterFn(lowerer: Lowerer, info: ClassInfo, prop: string): IrFunction;
 /** The class's OWN field initializers as fieldSet statements (declaration
    * order) — a base constructor's prologue, a derived constructor's
    * super()-return continuation. */
-export declare function fieldInitStmts(L: Lowerer, info: ClassInfo, thisLocal: IrLocal): IrStmt[];
-/** PARAMETER-PROPERTY assignments (`this.x = x`, synthesized): run AFTER
-   * the field initializers — Node's transform defines the fields at the
-   * top of the class body (undefined until assigned) and injects the
-   * assignments at the start of the constructor body, i.e. after super()
-   * and after the (native) field initializers ran (probed: a field
-   * initializer reading `this.x` sees undefined; the body sees the value).
-   * Each assignment reads the parameter's BODY local (defaults already
-   * applied by the declareParams prologue), whose type the collection made
-   * the field's type — slot-exact by construction. */
-export declare function paramPropInitStmts(L: Lowerer, info: ClassInfo, thisLocal: IrLocal): IrStmt[];
+export declare function fieldInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal): IrStmt[];
 /** A derived constructor's body: statements lower as usual EXCEPT the
    * top-level `super(...)` statement, which becomes a direct call to the
    * base constructor over the same `this`, immediately followed by this
@@ -713,7 +666,7 @@ export declare function paramPropInitStmts(L: Lowerer, info: ClassInfo, thisLoca
    * guarantees a super call exists and runs before any this-use; the
    * supported form is a top-level expression statement — anywhere else
    * (conditionals, expression positions) is rejected, not misordered. */
-export declare function lowerDerivedCtorBody(L: Lowerer, info: ClassInfo, thisLocal: IrLocal, 
+export declare function lowerDerivedCtorBody(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal, 
 /** Mixin forwarding-constructor mode: `super(...args)` forwards these
  * pre-declared synthetic params directly (the spread never lowers —
  * the base's ABI is this constructor's ABI). */
@@ -721,59 +674,43 @@ forward?: IrExpr[]): IrStmt[];
 /** `super(args)` → direct call of the base constructor with the SAME
    * `this` (upcast; retained by the varRef read — the callee owns and
    * releases its param per the universal convention). */
-export declare function superCallStmt(L: Lowerer, info: ClassInfo, thisLocal: IrLocal, args: IrExpr[], loc: SrcLoc): IrStmt;
+export declare function superCallStmt(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal, args: IrExpr[], loc: SrcLoc): IrStmt;
 /** `super.method(args)`: the base chain's implementation, called
    * DIRECTLY over this method's own `this` (upcast to the declarer) —
    * super dispatch is static in JS too, never through the dynamic class. */
-export declare function lowerSuperMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr;
+export declare function lowerSuperMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr;
 /** The `this` reference for super accessor reads/writes, with the shared
    * validity checks (derived-class body, resolvable this). */
-export declare function superThisRef(L: Lowerer, access: ts.PropertyAccessExpression): {
+export declare function superThisRef(lowerer: Lowerer, access: ts.PropertyAccessExpression): {
     thisRef: IrExpr;
     base: ClassInfo;
 };
 /** `super.x` read: a DIRECT call of the base chain's getter over this
    * method's own `this` (upcast to the declarer) — like super.method(),
    * never through the vtable. */
-export declare function lowerSuperAccessorRead(L: Lowerer, access: ts.PropertyAccessExpression): IrExpr;
+export declare function lowerSuperAccessorRead(lowerer: Lowerer, access: ts.PropertyAccessExpression): IrExpr;
 /** `super.x = v`: a DIRECT call of the base chain's setter (same
    * static-dispatch rule as every super member access). */
-export declare function lowerSuperAccessorWrite(L: Lowerer, access: ts.PropertyAccessExpression, rhs: ts.Expression, loc: SrcLoc): IrStmt;
+export declare function lowerSuperAccessorWrite(lowerer: Lowerer, access: ts.PropertyAccessExpression, rhs: ts.Expression, loc: SrcLoc): IrStmt;
 /** True when `info`'s EFFECTIVE constructor — its own, or the one
    * inherited through ctor-less bases — is a builtin error class's. Such
    * classes construct with the error message rule, and their synthesized
    * constructors forward one plain string to error.ctor. */
-export declare function inheritsBuiltinErrorCtor(L: Lowerer, info: ClassInfo): boolean;
+export declare function inheritsBuiltinErrorCtor(lowerer: Lowerer, info: ClassInfo): boolean;
 /** The EventEmitter twin: a ctor-less chain into the emitter base
    * inherits `new C()` — zero arguments (the options bag fences). */
-export declare function inheritsBuiltinEmitterCtor(L: Lowerer, info: ClassInfo): boolean;
-/** The stream twin: a ctor-less chain into a runtime stream base
-   * inherits `new C()` — zero arguments (the synthesized constructor runs
-   * super() with default options; passing options through an inherited
-   * constructor would need the literal at the new-site to plumb, so it
-   * asks for a declared constructor instead). */
-export declare function inheritsBuiltinStreamCtor(L: Lowerer, info: ClassInfo): boolean;
+export declare function inheritsBuiltinEmitterCtor(lowerer: Lowerer, info: ClassInfo): boolean;
 /** `new C(args)` for a class declared in the program (imports resolve
    * through aliases, so cross-module classes construct too). */
 /** The single message argument of a builtin Error construction or
  * super() call: "" when omitted or explicitly undefined (Node's message
  * property default), the string otherwise. The lib signature's second
  * parameter (options/cause) has no lowering. */
-export declare function errorMessageArg(L: Lowerer, args: readonly ts.Expression[], loc: SrcLoc, blame: ts.Node): IrExpr;
-/** A class whose decoration provably throws has no reachable VALUE form:
- * the binding never initializes (the %init ReferenceError unwinds first),
- * so `new`, the class as a value, and `extends` all fence — reaching one
- * in compiled code would require executing past the throw. */
-export declare function fenceDecorationThrows(L: Lowerer, info: ClassInfo, blame: ts.Node): void;
-export declare function lowerNew(L: Lowerer, expr: ts.NewExpression): IrExpr;
+export declare function errorMessageArg(lowerer: Lowerer, args: readonly ts.Expression[], loc: SrcLoc, blame: ts.Node): IrExpr;
+export declare function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr;
 /** A getter/setter invocation over an accessor target's receiver — the
    * same whole-program devirtualization as method calls: a virtualCall
    * when some strict subclass of the receiver's static class overrides
    * this HALF of the accessor (get and set devirtualize independently),
    * a direct call of the nearest declaration otherwise. */
-export declare function accessorCall(L: Lowerer, className: string, member: string, obj: IrExpr, extraArgs: IrExpr[], ret: IrType, loc: SrcLoc): IrExpr;
-/** The generic function-like INITIALIZER behind a class FIELD —
- * `time = async <T>(...) => {...}` or `= function g<T>(...) {...}`
- * (parens stripped): bindingGenericFnNodeOf's shape rule, member form.
- * Null when the field isn't that shape. */
-export declare function genericFieldFnNodeOf(member: ts.PropertyDeclaration): ts.FunctionExpression | ts.ArrowFunction | null;
+export declare function accessorCall(lowerer: Lowerer, className: string, member: string, obj: IrExpr, extraArgs: IrExpr[], ret: IrType, loc: SrcLoc): IrExpr;