@scriptc/compiler 0.2.4 → 0.2.6

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

@@ -1,7 +1,9 @@
 import * as ts from "../ts7/adapter.js";
 import type { FnCtx, Lowerer } from "./lowerer.js";
 import { type IrClassDef, type IrExpr, type IrFunction, type IrLocal, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
-import { type GenericFnInfo, type ParamShape } from "./lower-calls.js";
+import { type GenericFnInfo } from "./generic-functions.js";
+import { type InstantiationPath } from "./instantiation-path.js";
+import { type ParamShape } from "./call-signatures.js";
 import { type ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type EmitOverrideRec } from "./lower-event-emitter.js";
 import { type MixinInstanceInfo } from "./lower-mixins.js";
@@ -130,6 +132,8 @@ export interface ClassInfo {
      * (forwarding the completed ABI values; defaults apply in the base). */
     ctorParams: ParamShape[];
     base: ClassInfo | null;
+    /** Family heritage resolves its type arguments separately for each instance. */
+    genericBase?: ts.ExpressionWithTypeArguments;
     /** A module class may inherit a compiled ordinary JS constructor. Its
      * callable and prototype are captured when the class declaration runs. */
     callableBase?: {
@@ -213,6 +217,7 @@ export interface ClassInfo {
      * counts statements toward coverage — re-instantiations re-visit the
      * same source lines). */
     genericInstance?: {
+        path: InstantiationPath;
         family: ClassInfo;
         bindings: Map<ts.Symbol, IrType>;
         typeArgsText: string;
@@ -306,75 +311,76 @@ export interface GenericClassInfo {
     }>;
 }
 /** The builtin Error hierarchy
-   * as eagerly-registered ClassInfos: mapType names them the moment a lib
-   * Error type appears, so the infos must exist before any lowering. They
-   * are runtime-provided — no decl, no lowerable bodies; `new`/super()/
-   * toString reach them through dedicated error.* libCall lowerings, and
-   * user classes extend them like any base (the emitted subclass struct
-   * embeds ScrError's prefix). */
+ * as eagerly-registered ClassInfos: mapType names them the moment a lib
+ * Error type appears, so the infos must exist before any lowering. They
+ * are runtime-provided — no decl, no lowerable bodies; `new`/super()/
+ * 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(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-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). */
+ * 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-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(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
-   * lowering. Each roots at the emitter through its base chain, so the
-   * EventEmitter method surface, upcasts, and instanceof intervals apply
-   * 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). */
+ * ClassInfos (the emitter story): mapType names `%Readable` et al the
+ * moment a stream type appears, so the infos must exist before any
+ * lowering. Each roots at the emitter through its base chain, so the
+ * EventEmitter method surface, upcasts, and instanceof intervals apply
+ * 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(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
-   * "stream" ambient module, EXCLUDING @types/node's (whose stream.Readable
-   * 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). */
+ * `x instanceof Writable`) — any import spelling resolves to the
+ * ambient class. Provenance: a stdlib-file CLASS declaration inside the
+ * "stream" ambient module, EXCLUDING @types/node's (whose stream.Readable
+ * 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(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. */
+ * `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(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. */
+ * `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(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-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). */
+ * `modifiers` since TS 4.8). */
 export declare function decoratorNodesOf(n: ts.Node): ts.Decorator[];
 /** 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
-   * order its decorators and computed key (the verified TC39/tsc-downlevel
-   * order) — and answers the first AMBIENT decorator name, provided every
-   * item BEFORE it is provably effect-free and non-throwing: bare
-   * identifier decorators over defined values (a pure read), an absent /
-   * `null` / bare-identifier heritage, literal or bare-identifier
-   * computed keys. Anything richer (factory calls over defined values,
-   * property-access reads, computed-key calls) stops the proof — the
-   * named fences answer instead. */
+ * the class definition's evaluation-order items — class decorators
+ * (source order), the heritage expression, then per member in body
+ * order its decorators and computed key (the verified TC39/tsc-downlevel
+ * order) — and answers the first AMBIENT decorator name, provided every
+ * item BEFORE it is provably effect-free and non-throwing: bare
+ * identifier decorators over defined values (a pure read), an absent /
+ * `null` / bare-identifier heritage, literal or bare-identifier
+ * 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(lowerer: Lowerer, decl: ts.ClassLikeDeclaration): {
     name: string;
     node: ts.Decorator;
 } | null;
 export declare function collectClassShape(lowerer: Lowerer, decl: ts.ClassDeclaration): void;
 export declare function collectClassShapeInner(lowerer: Lowerer, decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
+    path: InstantiationPath;
     family: ClassInfo;
     name: string;
     bindings: Map<ts.Symbol, IrType>;
@@ -395,45 +401,45 @@ mixin?: {
     ordinal: number;
 }): void;
 /** mapType's generic-class hook: the INSTANTIATION a concrete type
-   * reference (`Box<number>`) names — registered on first demand. The
-   * instance's NAME reserves its key before the shape collects, so
-   * self-referential layouts (`next: Box<T> | null`) re-enter here and
-   * take the name without recursing; a poisoned collection (a field type
-   * with no lowering under these bindings — the diagnostic carries the
-   * instantiation context) leaves the entry poisoned and the type
-   * 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. */
+ * reference (`Box<number>`) names — registered on first demand. The
+ * instance's NAME reserves its key before the shape collects, so
+ * self-referential layouts (`next: Box<T> | null`) re-enter here and
+ * take the name without recursing; a poisoned collection (a field type
+ * with no lowering under these bindings — the diagnostic carries the
+ * instantiation context) leaves the entry poisoned and the type
+ * 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(lowerer: Lowerer, decl: ts.ClassLikeDeclaration, ref: ts.Type, mapArgument?: (type: ts.Type) => IrType | null): 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. */
+ * 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(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:
-   * exactly one parameter, itself a classval the decorated class legally
-   * flows into (the class, or a base sharing its completed constructor
-   * ABI — the classval widening rule), returning void/undefined (an
-   * effect-only decorator) or the class/a same-ABI subclass (a REPLACING
-   * decorator, whose result rebinds the name). Everything else is a named
-   * fence: the standard context parameter, structural sibling
-   * replacements tsc admits but the nominal classval world cannot carry,
-   * unions mixing the class with undefined. A replacing decorator
-   * registers the mutable classval global the name rebinds through, and
-   * fences the two shapes the value rebinding cannot keep exact —
-   * subclasses of the decorated class (the compiled hierarchy is fixed at
-   * 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). */
+ * a decorator's return type may name a subclass declared BELOW the
+ * class). Classifies every class-level decorator by its checker type:
+ * exactly one parameter, itself a classval the decorated class legally
+ * flows into (the class, or a base sharing its completed constructor
+ * ABI — the classval widening rule), returning void/undefined (an
+ * effect-only decorator) or the class/a same-ABI subclass (a REPLACING
+ * decorator, whose result rebinds the name). Everything else is a named
+ * fence: the standard context parameter, structural sibling
+ * replacements tsc admits but the nominal classval world cannot carry,
+ * unions mixing the class with undefined. A replacing decorator
+ * registers the mutable classval global the name rebinds through, and
+ * fences the two shapes the value rebinding cannot keep exact —
+ * subclasses of the decorated class (the compiled hierarchy is fixed at
+ * 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(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). */
+ * 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(lowerer: Lowerer, info: ClassInfo | null, name: string): {
     declarer: ClassInfo;
     field: ClassInfo["staticFields"][number];
@@ -449,30 +455,30 @@ export declare function findStaticOn(lowerer: Lowerer, info: ClassInfo | null, n
     field?: undefined;
 } | null;
 /** True when some STRICT descendant of `info` redeclares static `name` —
-   * 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(lowerer: Lowerer, info: ClassInfo, name: string): boolean;
+ * 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(info: ClassInfo, name: string): boolean;
 /** The nearest GENERIC static declaration of `name` at/above `info` —
-   * findStaticOn's twin over the genericStatics tables. */
+ * findStaticOn's twin over the genericStatics tables. */
 export declare function findGenericStaticOn(lowerer: Lowerer, info: ClassInfo | null, name: string): {
     declarer: ClassInfo;
     info: GenericFnInfo;
 } | null;
 /** The class itself taken as a VALUE (`const X = C`, an argument, an
-   * array element, a class expression's result): the classRef over the
-   * per-class immortal class object. The construct thunk needs a thunk-
-   * shaped constructor, so classes whose construction is libCall-shaped —
-   * the runtime-provided builtins and anything inheriting a builtin
-   * 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. */
+ * array element, a class expression's result): the classRef over the
+ * per-class immortal class object. The construct thunk needs a thunk-
+ * shaped constructor, so classes whose construction is libCall-shaped —
+ * the runtime-provided builtins and anything inheriting a builtin
+ * 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(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. */
+ * 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(lowerer: Lowerer, sub: ClassInfo, sup: ClassInfo): boolean;
 /** Writable storage for an own static field named through its exact class.
  * Inherited writes create a new subclass property in JS, so they must not
@@ -482,11 +488,11 @@ export declare function staticFieldWriteTarget(lowerer: Lowerer, access: ts.Prop
     type: IrType;
 } | null;
 /** `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. */
+ * 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(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** Collect a class expression once per enclosing specialization. Function-local
  * evaluations allocate fresh constructor objects; top-level expressions use
@@ -494,57 +500,57 @@ export declare function lowerStaticFieldRead(lowerer: Lowerer, expr: ts.Property
  * initializers, where pendingClassExprInits preserves its evaluation point. */
 export declare function lowerClassExpressionInfo(lowerer: Lowerer, expr: ts.ClassLikeDeclaration): 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
-   * whose decoration provably throws (the ambient-decorator shape) never
-   * mints a class at all: evaluating the expression IS the
-   * 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. */
+ * statement — once the static side is a value, the expression IS the
+ * definition plus a classRef over it. A DECORATED class expression
+ * whose decoration provably throws (the ambient-decorator shape) never
+ * mints a class at all: evaluating the expression IS the
+ * 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(lowerer: Lowerer, expr: ts.ClassLikeDeclaration): 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. */
+ * 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(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 {…}` /
-   * `module.exports.I = class {…}` (CJS member exports), and
-   * `module.exports = class {…}` (the whole-export replacement, whose
-   * export symbol requirer bindings alias to). The symbol arrives in two
-   * shapes — an ALIAS resolving to the class expression's own symbol
-   * (valueDeclaration IS the ts.ClassExpression), or the expando property
-   * symbol whose declarations are the assignment BinaryExpressions — and
-   * both pin the class exactly when ONE top-level assignment declares it:
-   * a reassigned property is a dynamic binding (the runtime class is
-   * whichever assignment ran last), so it answers null and the caller's
-   * fence names it. Collection is on demand and idempotent
-   * (lowerClassExpressionInfo), so resolution order between files and
-   * passes never matters. */
+ * declaration forms of a class expression: `Common.I = class {…}`
+ * (expando members of a plain object), `exports.I = class {…}` /
+ * `module.exports.I = class {…}` (CJS member exports), and
+ * `module.exports = class {…}` (the whole-export replacement, whose
+ * export symbol requirer bindings alias to). The symbol arrives in two
+ * shapes — an ALIAS resolving to the class expression's own symbol
+ * (valueDeclaration IS the ts.ClassExpression), or the expando property
+ * symbol whose declarations are the assignment BinaryExpressions — and
+ * both pin the class exactly when ONE top-level assignment declares it:
+ * a reassigned property is a dynamic binding (the runtime class is
+ * whichever assignment ran last), so it answers null and the caller's
+ * fence names it. Collection is on demand and idempotent
+ * (lowerClassExpressionInfo), so resolution order between files and
+ * passes never matters. */
 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
-   * VALUE the call devirtualizes exactly when no strict descendant
-   * redeclares the member (values never leave the static class's
-   * subtree). A func-typed static FIELD in call position reads the
-   * 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). */
+ * directly or through a class VALUE. Resolution walks the chain
+ * (nearest declarer, the compile-time prototype chain); through a
+ * VALUE the call devirtualizes exactly when no strict descendant
+ * redeclares the member (values never leave the static class's
+ * subtree). A func-typed static FIELD in call position reads the
+ * 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(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
-   * (values in the slot never leave the subtree). `X.name` is the one
-   * 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. */
+ * classval-typed): devirtualized — the member resolves against the
+ * static class's chain, exact when no strict descendant redeclares it
+ * (values in the slot never leave the subtree). `X.name` is the one
+ * 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(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. */
+ * receiver of that static class runs when nothing below overrides it. */
 export declare function findMethodOn(lowerer: Lowerer, info: ClassInfo | null, name: string): {
     declarer: ClassInfo;
     sig: {
@@ -558,26 +564,26 @@ export declare function findMethodOn(lowerer: Lowerer, info: ClassInfo | null, n
 /** True when `sub` is a STRICT descendant of `sup` in the class graph. */
 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. */
+ * vtable and participates in dynamic instanceof; standalone classes keep
+ * their exact pre-inheritance layout and behavior. */
 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). */
+ * — 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(lowerer: Lowerer, info: ClassInfo, name: string): boolean;
 /** The nearest GENERIC-method declaration of `name` at/above `info` —
-   * findMethodOn's twin over the genericMethods tables. */
+ * findMethodOn's twin over the genericMethods tables. */
 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(lowerer: Lowerer, info: ClassInfo, name: string): boolean;
+ * 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(info: ClassInfo, name: string): boolean;
 /** Discover inherited data writes before any base storage ABI is chosen.
  * The checker does not widen a base field for assignments in JS subclasses. */
 export declare function collectInheritedJsFieldWrites(lowerer: Lowerer, files: readonly ts.SourceFile[]): void;
@@ -587,69 +593,69 @@ export declare function collectInheritedJsFieldWrites(lowerer: Lowerer, files: r
  * hierarchy identifies the original declarations through aliases as well. */
 export declare function collectVirtualJsMethods(lowerer: Lowerer, files: readonly ts.SourceFile[]): void;
 /** 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. */
+ * `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(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
-   * excluded (no closure slot can hold a generic function) — so the
-   * copy-reshape width coercion would DROP the exact class the method
-   * calls monomorphize against, and in JS the binding IS the instance (no
-   * copy exists). The binding keeps the initializer's class
-   * representation instead: generic-method calls resolve like class-typed
-   * receivers (exactInstanceClassOf reads the same const+new discipline),
-   * 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. */
+ * checker type is a generic-callable method (`interface Repo { get<T>(id:
+ * string): T }`): the record shape maps EMPTY — generic members are
+ * excluded (no closure slot can hold a generic function) — so the
+ * copy-reshape width coercion would DROP the exact class the method
+ * calls monomorphize against, and in JS the binding IS the instance (no
+ * copy exists). The binding keeps the initializer's class
+ * representation instead: generic-method calls resolve like class-typed
+ * receivers (exactInstanceClassOf reads the same const+new discipline),
+ * 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(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
-   * the call is a direct `call` of `%C.m%n` over the (up/down)cast
-   * receiver. No per-instantiation vtable slots exist, so a receiver whose
-   * runtime class could OVERRIDE the method (genericOverrideBelow) must be
-   * statically exact (exactInstanceClassOf) — the override set then
-   * resolves at compile time — or fences by name. */
+ * checker's resolved signature (type arguments substituted, inferred or
+ * explicit) keys one instantiation of the nearest declarer's body, and
+ * the call is a direct `call` of `%C.m%n` over the (up/down)cast
+ * receiver. No per-instantiation vtable slots exist, so a receiver whose
+ * 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(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). */
+ * class differs (a no-op reinterpret at runtime; keeps IR types exact). */
 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. */
+ * 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(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
-   * applied to method positions; tsc late-bound the member under exactly
-   * that name), or a reserved `sym:*` slot for the well-known symbols the
-   * compiler consumes as language protocols (iterator and explicit
-   * resource management). These names are unspellable as user identifiers,
-   * like the accessor `get:x` convention. Null for genuinely
-   * runtime-keyed names — the computed-member fences stay. */
+ * COMPUTED name that folds to one compile-time string
+ * (foldedStringKeyOf — the object-literal computed-key machinery
+ * applied to method positions; tsc late-bound the member under exactly
+ * that name), or a reserved `sym:*` slot for the well-known symbols the
+ * compiler consumes as language protocols (iterator and explicit
+ * resource management). These names are unspellable as user identifiers,
+ * like the accessor `get:x` convention. Null for genuinely
+ * runtime-keyed names — the computed-member fences stay. */
 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
-   * `next()` returns a record with a `value` field and an optional
-   * boolean `done` field (`{ value, done: false }` — the self-iterator
-   * idiom returns `this`, so the iterator class is usually the receiver
-   * itself). A MISSING done field never terminates — exactly JS, where
-   * `undefined` is falsy forever (Node loops forever too; corpus
-   * iterators of that shape are deliberately infinite). Iterator classes
-   * declaring `return`/`throw` members stay out — the desugars below
-   * never call IteratorClose, and silently skipping a declared return()
-   * would drop user cleanup. Null when the shape doesn't hold — callers
-   * keep their fences. */
+ * receiver declares (or inherits) `[Symbol.iterator]()` (the
+ * "sym:iterator" method slot) returning a class whose zero-parameter
+ * `next()` returns a record with a `value` field and an optional
+ * boolean `done` field (`{ value, done: false }` — the self-iterator
+ * idiom returns `this`, so the iterator class is usually the receiver
+ * itself). A MISSING done field never terminates — exactly JS, where
+ * `undefined` is falsy forever (Node loops forever too; corpus
+ * iterators of that shape are deliberately infinite). Iterator classes
+ * declaring `return`/`throw` members stay out — the desugars below
+ * never call IteratorClose, and silently skipping a declared return()
+ * would drop user cleanup. Null when the shape doesn't hold — callers
+ * keep their fences. */
 export interface ClassIteratorInfo {
     /** The `[Symbol.iterator]()` call's receiver class + its declarer. */
     className: string;
@@ -667,78 +673,78 @@ export interface ClassIteratorInfo {
 }
 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. */
+ * virtual) method call. */
 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(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
-   * forever, exactly Node's spread of an infinite iterator). `elemT`
-   * (default: the iterator's own value type) is the DESTINATION element —
-   * a spread into a union-element literal (`[...numbers, ...symbols]` as
-   * `(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. */
+ * an interned `%iter.drain.<n>(recv)` lifted function running the
+ * whole protocol into a fresh element array (a doneless iterator loops
+ * forever, exactly Node's spread of an infinite iterator). `elemT`
+ * (default: the iterator's own value type) is the DESTINATION element —
+ * a spread into a union-element literal (`[...numbers, ...symbols]` as
+ * `(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(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. */
+ * 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(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). */
+ * (accessors are methods with property syntax: "get:x"/"set:x" entries —
+ * see collectClassShape). */
 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
-   * who() is declared on E), which has no static story here: both are
-   * named fences, with arrow functions transparent (they inherit the
-   * method's `this`) and this-binding function forms opaque — the static-
-   * block rule verbatim. */
+ * ordinary function with NO `this` param. `this` and `super` inside
+ * name the RECEIVER class in JS (dynamic — `F.who()` sees F even when
+ * who() is declared on E), which has no static story here: both are
+ * 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(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). */
+ * 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(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. */
+ * order) — a base constructor's prologue, a derived constructor's
+ * super()-return continuation. */
 export declare function fieldInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal): IrStmt[];
 /** Super statements initialize the base and then the derived fields on
-   * whichever control-flow path executes. Repeated calls are explicitly
-   * refused until native layouts can allocate a second receiver. */
+ * whichever control-flow path executes. Repeated calls are explicitly
+ * refused until native layouts can allocate a second receiver. */
 export declare function lowerDerivedCtorBody(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal, 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). */
+ * `this` (upcast; retained by the varRef read — the callee owns and
+ * releases its param per the universal convention). */
 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. */
+ * 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(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). */
+ * validity checks (derived-class body, resolvable this). */
 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. */
+ * method's own `this` (upcast to the declarer) — like super.method(),
+ * never through the vtable. */
 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). */
+ * static-dispatch rule as every super member access). */
 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 argument rule, and their synthesized
-   * constructors forward both checked-dynamic values to error.ctorOptions. */
+ * inherited through ctor-less bases — is a builtin error class's. Such
+ * classes construct with the error argument rule, and their synthesized
+ * constructors forward both checked-dynamic values to error.ctorOptions. */
 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). */
+ * inherits `new C()` — zero arguments (the options bag fences). */
 export declare function inheritsBuiltinEmitterCtor(lowerer: Lowerer, info: ClassInfo): boolean;
 /** Preserve argument evaluation order and option presence through builtin
  * and inherited Error constructors. Checked-dynamic conversion retains
@@ -746,8 +752,8 @@ export declare function inheritsBuiltinEmitterCtor(lowerer: Lowerer, info: Class
 export declare function errorConstructorArgs(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. */
+ * 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(lowerer: Lowerer, className: string, member: string, obj: IrExpr, extraArgs: IrExpr[], ret: IrType, loc: SrcLoc): IrExpr;