@scriptc/compiler 0.1.7 → 0.2.1

package/dist/frontend/lowering/lowerer.d.ts

@@ -1,56 +1,30 @@
+import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
+import type { WidthLift } from "./width-lift.js";
+export type { WidthLift } from "./width-lift.js";
+import { type FnCtx } from "./function-context.js";
+export { newFnCtx, type FnCtx } from "./function-context.js";
+import type { FrontendServices } from "../services.js";
+import type { ClassSymbolKey } from "./symbol-fields.js";
+import type { HttpClientFnBinding } from "./lower-server.js";
 import * as ts from "../ts7/adapter.js";
+import { type UnionLiteral } from "../union-discriminants.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { UNSUPPORTED } from "../../diagnostics/diagnostic.js";
 import type { IrClassDef, IrExpr, IrFfiImport, IrFunction, IrGlobal, IrLocal, IrModule, IrParam, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
 import { type DynamicImportResolution, type NpmBuiltinUse, type NpmLazyTrap } from "../npm.js";
 import { type StartupCrash } from "../program.js";
 import { ShapeRegistry, type TypeMapperCtx, UnionRegistry } from "../type-mapper.js";
-import { CompoundOp, IslandFnEntry, BuiltinModuleFn } from "./surfaces.js";
-import { FileParts } from "./lower-modules.js";
-import { ClassInfo, ClassIteratorInfo, GenericClassInfo, findStaticOn } from "./lower-classes.js";
-import { MixinFnShape } from "./lower-mixins.js";
-import { ParamShape, FnSig, GenericFnInfo, GenericInstance } from "./lower-calls.js";
-import { type EmitSpecCtx, type EmitSpecRequest } from "./lower-event-emitter.js";
-import { FieldTarget } from "./lower-exprs.js";
-import type { ExpandoMember } from "./lower-expando.js";
+import { type CompoundOp, type IslandFnEntry, type BuiltinModuleFn } from "./surfaces.js";
+import { type FileParts } from "./lower-modules.js";
+import { type ClassInfo, type ClassIteratorInfo, type GenericClassInfo, findStaticOn } from "./lower-classes.js";
+import { type MixinFnShape } from "./lower-mixins.js";
+import { type ParamShape, type FnSig, type GenericFnInfo, type GenericInstance } from "./lower-calls.js";
+import { type ComputedEventPattern, type EmitSpecCtx, type EmitSpecRequest, type EventSig } from "./lower-event-emitter.js";
+import { type FieldTarget } from "./lower-exprs.js";
+import type { ExpandoMembers } from "./lower-expando.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
  * function can never collide with it (mangling is injective per prefix). */
 export declare const ENTRY_NAME = "%main";
-/** One step of the copy-reshape width relation (widthLiftPlan): how a
- * source-typed value enters a destination slot. Pure data — the plan half;
- * applyWidthLift is the build half. */
-export type WidthLift = {
-    how: "copy";
-} | {
-    how: "wrap";
-    tag: number;
-} | {
-    how: "retag";
-} | {
-    how: "liftWrap";
-    tag: number;
-    arm: IrType;
-} | {
-    how: "width";
-} | {
-    how: "arr";
-} | {
-    how: "tupleArr";
-} | {
-    how: "emptyArr";
-} | {
-    how: "objWidth";
-} | {
-    how: "clsWidth";
-} | {
-    how: "narrow";
-} | {
-    how: "dynIn";
-} | {
-    how: "upcast";
-} | {
-    how: "funcAdapt";
-};
 export declare class PoisonError extends Error {
 }
 /** A function-shaped value that exists only in the compiler's static
@@ -77,64 +51,6 @@ export type StaticCallableProjection = {
  * NAMES user code can spell now that the real lib declares them; treating
  * an inherited function as a table entry would mis-lower or ICE. */
 export declare function own<T>(table: Record<string, T | undefined>, key: string): T | undefined;
-/** Per-function lowering context. A stack of these models nested functions:
- * identifier resolution walks outward, and a hit in an enclosing context
- * turns into a capture (boxing the binding at its origin and threading it
- * through every function in between). */
-export interface FnCtx {
-    locals: IrLocal[];
-    scopes: Map<ts.Symbol, IrLocal>[];
-    localCounters: Map<string, number>;
-    /** Lifted functions only: capture entries (also present in `locals`,
-     * boxed), in closure caps[] order. undefined ⇔ plain declared function. */
-    captures: IrParam[] | null;
-    /** Parent-function localIds feeding each capture, parallel to captures. */
-    captureSources: string[];
-    captureBySymbol: Map<ts.Symbol, IrLocal>;
-    /** Named function expressions/declarations: the function's own name
-     * symbol. Self-references become `selfRef` (NOT a capture — a box holding
-     * its own closure would be an RC cycle and leak). */
-    selfSymbol: ts.Symbol | null;
-    selfType: IrType | null;
-    /** Await is legal here (async function body). */
-    isAsync?: boolean;
-    /** Yield is legal here (generator function body): the yield/next value
-     * channels the yield lowering types itself against. */
-    generator?: {
-        yieldT: IrType;
-        nextT: IrType;
-        resultType: IrType & {
-            kind: "record";
-        };
-    } | null;
-    /** VARIADIC `arguments` form (rest-marked func type with no declared
-     * rest param): the synthetic trailing dyn-array param `arguments`
-     * reads resolve to. */
-    argumentsLocal?: IrLocal | null;
-    /** Declared return type — lets `return` detect record-shape mismatches
-     * (SC2002) before the validator would ICE on them. */
-    returnType: IrType;
-    /** Implicit-any instance RETURN INFERENCE (resolveInferredReturn):
-     * present ⇔ `return` statements lower their values BARE (no coercion)
-     * and record themselves here; the post-pass unifies the types and wraps
-     * each return onto the settled one. `returnType` holds the DYN pin. */
-    inferReturn?: {
-        entries: {
-            stmt: IrStmt;
-            node: ts.Expression | null;
-        }[];
-    } | null;
-    /** Enclosing jump targets, innermost last. `labels` carries the source
-     * statement's JS label names so labeled break/continue resolve. Finally
-     * regions do not appear here: the backends route every abrupt completion
-     * through the cleanup regions it crosses. Per function, so a nested
-     * function's jumps never bind to enclosing constructs. */
-    ctl: {
-        kind: "loop" | "switch" | "block";
-        labels?: string[];
-    }[];
-}
-export declare function newFnCtx(lifted: boolean, selfSymbol: ts.Symbol | null, selfType: IrType | null, returnType: IrType): FnCtx;
 export interface LowerStats {
     /** Statements the lowerer attempted (nested statements count individually;
      * statements inside a poisoned construct were never reached and don't). */
@@ -148,14 +64,12 @@ export interface LowerStats {
     /** Functions whose signature couldn't be analyzed (bodies not counted). */
     functionsSkipped: number;
 }
-/** True when a lowered statement's OWN expressions contain island
- * constructs — a generic JSON walk (like moduleUsesRegex): `kind`
- * discriminants live only on IR objects, so user string values can never
- * false-positive. Nested statements are skipped (counted separately). */
 /** Every identifier a binding name binds: the identifier itself, or all
  * identifiers of a (possibly nested) destructuring pattern in source
  * order. */
 export declare function boundIdentifiersOf(name: ts.BindingName): ts.Identifier[];
+/** Inspect executable children directly, without boxing the statement tree
+ * into checked-dynamic storage just to calculate coverage. */
 export declare function stmtUsesIsland(stmts: IrStmt | IrStmt[]): boolean;
 export interface LowerResult {
     /** Present iff diagnostics is empty. */
@@ -190,6 +104,8 @@ export interface LowerResult {
     npmLazyTraps?: NpmLazyTrap[];
 }
 export interface LowerOptions {
+    /** Parser/checker services owned by the load; required for npm graph analysis. */
+    frontendServices?: FrontendServices | undefined;
     /** --dynamic: the island engine is linked, so island constructs
      * (__island_eval) may lower. Off by default — without it they produce a
      * requires-dynamic diagnostic instead. */
@@ -269,6 +185,7 @@ interface RuntimeFenceClosureTarget extends Omit<RuntimeFenceFunctionTarget, "ki
 }
 /** The Lowerer's pass configuration (see lowerToIr). */
 export interface LowererMode {
+    frontendServices?: FrontendServices | undefined;
     /** Names of bodies a prior reachability pass reached; null lowers everything. */
     reachable?: ReadonlySet<string> | null;
     /** Coverage remainder: lower ONLY bodies outside `reachable`, skip the
@@ -374,7 +291,7 @@ export declare function dynUndefinedExpr(loc: SrcLoc): IrExpr;
  * symbol-to-string TypeError). kind 0 Error / 1 TypeError / 2 RangeError;
  * an empty code means no code slot. `type` is the replaced expression's
  * own (never materialized — the global.undefRead pattern). */
-export declare function nodeThrowExpr(kind: 0 | 1 | 2, code: string, message: string, type: IrType, loc: SrcLoc): IrExpr;
+export declare function nodeThrowExpr(kind: 0 | 1 | 2 | 5, code: string, message: string, type: IrType, loc: SrcLoc): IrExpr;
 /** The post-validation fence STRING a validation-ladder Chk libCall
  * throws after its Node-order checks pass: the same SC2020 text the
  * per-statement runtime fence would have thrown (message + "[code at
@@ -421,6 +338,7 @@ export declare class Lowerer {
     readonly entry: ts.SourceFile;
     readonly moduleOrder: ts.SourceFile[];
     readonly dynamic: boolean;
+    readonly frontendServices: FrontendServices | undefined;
     readonly checker: ts.TypeChecker;
     readonly diags: ScrDiagnostic[];
     readonly fnSigsBySymbol: Map<ts.Symbol, FnSig>;
@@ -432,14 +350,14 @@ export declare class Lowerer {
     /** Object-literal GENERIC methods (`{ m<T>(x: T) {...} }`), interned by
      * their function-like node — instances ride the same monomorphization
      * queue (objLitGenericFnInfoOf). */
-    readonly objLitGenericFns: Map<ts.Node, GenericFnInfo>;
+    readonly objLitGenericFns: Map<import("../ts7/ast-node.js").AstNode, GenericFnInfo>;
     /** Generic arrow/function-expression INITIALIZERS of never-reassigned
      * bindings (`const f = <T>(x: T) => x`), interned by the function-like
      * node — registered in genericFnsBySymbol under the binding's symbol
      * (and a named function expression's own inner name), so calls and
      * pinned values resolve through genericFnOf exactly like top-level
      * generic function declarations (bindingGenericFnInfoOf). */
-    readonly bindingGenericFns: Map<ts.Node, GenericFnInfo>;
+    readonly bindingGenericFns: Map<import("../ts7/ast-node.js").AstNode, GenericFnInfo>;
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     readonly neverReassignedCache: Map<ts.Symbol, boolean>;
@@ -469,7 +387,7 @@ export declare class Lowerer {
     /** IMPLICIT-ANY function-value bindings (npm-static JS — `const knownBy
      * = (cmd) => ...`), by their VariableDeclaration: the registered info,
      * or null for probed non-qualifiers (implicitLocalFnNodeOf). */
-    readonly implicitLocalFns: Map<ts.Node, GenericFnInfo | null>;
+    readonly implicitLocalFns: Map<import("../ts7/ast-node.js").AstNode, GenericFnInfo | null>;
     /** Monomorphization worklist: instances queued by call sites, drained in
      * run() (processing an instance body can queue more). */
     readonly instantiationQueue: {
@@ -499,6 +417,10 @@ export declare class Lowerer {
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings: Map<ts.Symbol, IrType> | null;
+    localClassInstantiations: {
+        owner: ts.FunctionLikeDeclaration;
+        name: string;
+    }[];
     /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed
      * instance body lowers: type-parameter symbol → the bound CHECKER type,
      * consulted where the mapped IrType has already widened away information
@@ -523,10 +445,23 @@ export declare class Lowerer {
      * aliases, so this carries the var/let form the checker cannot.
      * Scoped strictly by narrowingAliases (lowerIf / lowerCondition). */
     readonly aliasNarrowTypes: Map<ts.Symbol, ts.Type>;
+    /** These caches belong to this lowering pass. The program already owns
+     * their symbol/node keys; no module-level cache should retain a pass. */
+    readonly classSymbolKeys: Map<ts.Symbol, ClassSymbolKey | null>;
+    readonly registeredClassSymbols: Map<string, ts.Symbol>;
+    readonly httpClientFnBindings: Map<ts.Symbol, HttpClientFnBinding>;
+    streamPropMutatedSyms: Set<ts.Symbol> | null;
+    requestInitPropMutatedSyms: Set<ts.Symbol> | null;
+    emitterEventTable: Map<string, EventSig> | null;
+    emitterComputedPatterns: ComputedEventPattern[];
     /** Locals widened beyond the checker's type because an inferred indexed
      * read can be absent at runtime. Bare reads preserve that union until a
      * surrounding JavaScript guard/default consumes it. */
-    readonly runtimeOptionalLocals: Set<IrLocal>;
+    readonly runtimeOptionalLocals: RuntimeOptionalLocals;
+    /** An effectful switch test can change the original binding after the
+     * discriminant was captured. A case match narrows the captured value,
+     * not that mutable binding; preserve its tagged representation on reads. */
+    readonly unstableSwitchBindings: Set<ts.Symbol>;
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     readonly runtimeOptionalStorageLocals: Set<IrLocal>;
@@ -545,18 +480,21 @@ export declare class Lowerer {
     readonly runtimeOptionalBindingTypes: Map<ts.Symbol, IrType>;
     /** Concise callback/lambda returns promoted by the HOF callback prepass;
      * arrows have no declaration symbol to key in fnSigsBySymbol. */
-    readonly runtimeOptionalFunctionReturns: WeakMap<ts.Node, IrType>;
+    readonly runtimeOptionalFunctionReturns: Map<import("../ts7/ast-node.js").AstNode, IrType>;
+    /** Intrinsic callback slots can supply a destination for fresh return
+     * literals, such as a reduce accumulator with recursive union fields. */
+    readonly contextualFunctionReturns: Map<import("../ts7/ast-node.js").AstNode, IrType>;
     /** Arithmetic over an unchecked string read can answer either NaN or a
      * string. Bindings and returns use this marker to retain that result union
      * through checker-bare string annotations. */
-    readonly runtimeOptionalArithmeticTypes: WeakMap<ts.Node, IrType>;
+    readonly runtimeOptionalArithmeticTypes: Map<import("../ts7/ast-node.js").AstNode, IrType>;
     /** Record fields promoted to an undefined-armed union by an indexed-read
      * value. The key is the concrete emitted shape and field name. */
     readonly runtimeOptionalFields: Set<string>;
     /** Callback pattern parameters carry an optional source without making
      * every name destructured from a present source optional. */
-    readonly runtimeOptionalPatternTypes: WeakMap<ts.Node, IrType>;
-    readonly runtimeOptionalReduceTypes: WeakMap<ts.CallExpression, IrType>;
+    readonly runtimeOptionalPatternTypes: Map<import("../ts7/ast-node.js").AstNode, IrType>;
+    readonly runtimeOptionalReduceTypes: Map<ts.CallExpression, IrType>;
     /** Capture entries and their origin share one mutable box. Normalize each
      * entry to the origin so writes and flow proofs stay synchronized. */
     readonly runtimeOptionalRoots: Map<IrLocal, IrLocal>;
@@ -651,6 +589,15 @@ export declare class Lowerer {
     /** Union re-tag helpers (%union.retag.N), interned per (from, to)
      * unionId pair — see unionRetagHelper. */
     readonly retagHelpers: Map<string, string>;
+    /** Copy-only routes depend on the two union contracts and discriminator
+     * layouts, without recursive width assumptions or evolving class members. */
+    private readonly copyRetagHelpers;
+    private readonly unionLiteralOwners;
+    private readonly strippedUndefinedArms;
+    private readonly stdlibSymbols;
+    /** Method adapter names are owned by class-method-values. Looking them
+     * up must not scan and retain every unrelated lifted function. */
+    readonly classMethodValueHelpers: Set<string>;
     /** Callee names of every interned coercion helper whose CALL mints a
      * FRESH closure per evaluation (%fn.width.*, %fn.adapt.*,
      * %fnval.spawnres.*). Registered at the mint site — NOT recovered by
@@ -669,7 +616,7 @@ export declare class Lowerer {
     /** CJS export-table ACCESSORS (`module.exports = { get path() {...} }`),
      * lifted lazily as module-level functions and interned per accessor
      * declaration: member reads call the getter (lower-exprs). */
-    readonly cjsAccessorFns: Map<ts.Node, {
+    readonly cjsAccessorFns: Map<import("../ts7/ast-node.js").AstNode, {
         fnName: string;
         type: IrType & {
             kind: "func";
@@ -712,9 +659,9 @@ export declare class Lowerer {
      * of re-lowering, its checker type reads non-nullish (typeOf), and the
      * node carrying the ?. token is marked handled so the receiver-typed
      * lowerings stop declining it (chainBlocked). */
-    readonly chainRecvByNode: Map<ts.Node, IrExpr>;
-    readonly chainNarrowedType: Map<ts.Node, ts.Type>;
-    readonly chainHandled: Set<ts.Node>;
+    readonly chainRecvByNode: Map<import("../ts7/ast-node.js").AstNode, IrExpr>;
+    readonly chainNarrowedType: Map<import("../ts7/ast-node.js").AstNode, ts.Type>;
+    readonly chainHandled: Set<import("../ts7/ast-node.js").AstNode>;
     /** for-of-over-matchAll bindings whose `.index` reads the companion-index
      * array: binding SYMBOL → the hidden number[] of match start indices plus
      * the hidden cursor holding THIS iteration's position (registered while
@@ -752,6 +699,15 @@ export declare class Lowerer {
     /** Keyed by program-wide qualified class name (what IR object types carry). */
     readonly classes: Map<string, ClassInfo>;
     readonly classBySymbol: Map<ts.Symbol, ClassInfo>;
+    /** Named method slots observed before class collection need a callable
+     * ABI and shared prototype descriptors instead of call-site specialization. */
+    readonly prototypeMethodAccesses: Map<string, import("../ts7/ast-node.js").AstNode>;
+    /** Inferred JS methods participating in an override chain keep a vtable
+     * ABI instead of call-site specialization. Filled before class collection. */
+    readonly virtualJsMethods: Set<ts.MethodDeclaration>;
+    /** Largest fixed argument list below a JS method, discovered before any
+     * base vtable signature is collected. Unused checked slots carry undefined. */
+    readonly virtualJsMethodArity: Map<ts.MethodDeclaration, number>;
     /** The class whose members are lowering — `super` binds lexically to it
      * (arrows inside methods lower within this window, so they see it too). */
     currentClass: ClassInfo | null;
@@ -760,12 +716,12 @@ export declare class Lowerer {
      * or callable const): per function symbol, each written member's module
      * global — string keys for spelled/folded names, ts.Symbols for
      * unique-symbol keys (lower-expando.ts). */
-    readonly expandoMembers: Map<ts.Symbol, Map<string | ts.Symbol, ExpandoMember>>;
+    readonly expandoMembers: Map<ts.Symbol, ExpandoMembers>;
     /** CJS export globals ALSO key by their declaration NODE: the checker
      * hands importers a distinct (late-bound) symbol for `module.exports`
      * property exports — different object, same declaration — so globalOf
      * falls back through the shared node (collectGlobals registers both). */
-    readonly globalsByDeclNode: Map<ts.Node, IrGlobal>;
+    readonly globalsByDeclNode: Map<import("../ts7/ast-node.js").AstNode, IrGlobal>;
     readonly globalsList: IrGlobal[];
     /** npm-import init statements (--dynamic), keyed by file AND import
      * declaration: the island.import assignments/side-effect loads for that
@@ -807,6 +763,7 @@ export declare class Lowerer {
      * engine handle (a dynamic import's namespace object) — paramShape's
      * early-out. */
     readonly jsvalParamOverrides: Set<ts.ParameterDeclaration>;
+    readonly checkedCallbackParams: Set<ts.ParameterDeclaration>;
     /** Inline Promise.then parameters whose contextual type is a builtin
      * module namespace anonymous object. The settled native token is the
      * ABI truth even when the checker type has no stable module symbol. */
@@ -827,7 +784,7 @@ export declare class Lowerer {
      * non-instantiated one (its only value members are import= aliases,
      * still resolved statically). Ambient blocks never register — their
      * members keep the ReferenceError/fence paths (lower-namespaces.ts). */
-    readonly nsBlocks: Map<ts.Node, "flattened" | "typeOnly">;
+    readonly nsBlocks: Map<import("../ts7/ast-node.js").AstNode, "flattened" | "typeOnly">;
     /** File → its %init function name, filled by prepareModuleInits before
      * any body lowers: import headers and inline require statements call
      * dependency inits by these names. */
@@ -894,7 +851,13 @@ export declare class Lowerer {
     onEdge: ((name: string) => void) | null;
     fnStack: FnCtx[];
     readonly liftedFns: IrFunction[];
+    /** One Error-method helper belongs to this lowering session. Its cached
+     * dispatch revision needs no weak-key identity or process-global state. */
+    errorMethodDispatchRevision: string | null;
+    errorPropertyDispatchRevision: string | null;
     lambdaCounter: number;
+    readonly preparedClassFactories: Map<ts.ArrowFunction | ts.FunctionExpression, IrExpr>;
+    readonly preparingClassFactories: Set<ts.ArrowFunction | ts.FunctionExpression>;
     /** Statement lists currently mid-lowering, innermost last: the forward-
      * capture machinery needs to know which later statements of an OPEN list
      * a symbol's declaration sits in, which scope frame list-level declarations
@@ -907,20 +870,6 @@ export declare class Lowerer {
         frame: Map<ts.Symbol, IrLocal>;
         out: IrStmt[];
     }[];
-    /** Forward-captured consts pre-declared as TDZ boxes, keyed by symbol:
-     * lowerVarDecl consumes the entry when the source declaration arrives and
-     * emits the initializing `assign` instead of a fresh declaration. */
-    readonly tdzPredeclared: Map<ts.Symbol, IrLocal>;
-    /** Nested function DECLARATIONS lowered eagerly by the forward-hoisting
-     * machinery (predeclareForwardFnDecl — a reference above the declaration
-     * in the same function, JS's function hoisting): the statement loop skips
-     * the source statement when it arrives. */
-    readonly hoistedFnDecls: Set<ts.FunctionDeclaration>;
-    /** `var` bindings hoisted to their function root (hoistVarBinding), keyed
-     * by the checker's merged symbol — every same-name `var` in one function
-     * is one symbol, so one slot. Module-scope vars live in globalsBySymbol
-     * instead. */
-    readonly hoistedVars: Map<ts.Symbol, IrLocal>;
     /** Per-file `var` module globals whose type carries an undefined arm:
      * lowerFileInit assigns them the interned undefined right after the
      * run-once guard — JS hoists module vars to `undefined` at entry, so a
@@ -1148,15 +1097,6 @@ export declare class Lowerer {
     /** Final retention, pruning, and module assembly shared by ordinary emit
      * and the retained reachability worklist. */
     finishModule(functions: IrFunction[]): LowerResult;
-    /** The unregistered-class type sweep (run()'s last step before the
-     * module assembles): every `{kind:"object"}` TYPE naming a class with
-     * no registered ClassInfo is rewritten IN PLACE to the f64 dummy.
-     * classval types are exempt (they emit the class-independent
-     * `ScrClassObj *` — inert-but-valid storage, the validator's own
-     * stance), and only type objects rewrite — node-level classNames
-     * (`new`, upcasts) cannot reach here (their lowerings fence without a
-     * registered class), so the validator still backstops those. */
-    sanitizeUnregisteredClassTypes(roots: unknown[]): void;
     /** True when `t` (recursively) names a class instance type with no
      * registered ClassInfo — the shape of a JS class whose collection fenced.
      * Used by run()'s global pruning; shapes/unions recurse with a seen-set
@@ -1247,8 +1187,9 @@ export declare class Lowerer {
     fenceStaticReadableStreamMember(access: ts.PropertyAccessExpression | ts.ElementAccessExpression, use: "read" | "call"): IrExpr | null;
     typeOf(node: ts.Node): ts.Type;
     /** mapType with this Lowerer's registries and (while a generic instance
-     * body lowers) type-parameter bindings threaded through. */
-    mapTypeOf(t: ts.Type): IrType | null;
+     * body lowers) type-parameter bindings threaded through. A supplied mapper
+     * retains interface-view substitutions while sharing ABI normalization. */
+    mapTypeOf(t: ts.Type, mapper?: (type: ts.Type) => IrType | null): IrType | null;
     /** The one position where a contextual UNION must not be adopted over the
      * expression's own: the LEFT operand of `&&`, `||`, or `??`. Adopting a
      * contextual union is normally safe because tsc proved the value
@@ -1353,6 +1294,11 @@ export declare class Lowerer {
      * this is THE tag for that (union, arm) pair program-wide — every wrap,
      * narrow, and tag test agrees by construction. */
     armTag(unionId: string, arm: IrType): number;
+    /** Literal ownership depends only on the union contract and record layouts.
+     * Recheck it when recursive placeholders close, not for every literal. */
+    literalUnionArm(unionId: string, values: readonly UnionLiteral[]): (IrType & {
+        kind: "record";
+    }) | null;
     /** Implicit union construction. Wherever a value flows into a typed slot
      * (initializer, assignment, call argument, return, field write, record
      * literal field, ternary arm) whose expected type is a union and the
@@ -1381,9 +1327,11 @@ export declare class Lowerer {
      * before any helper exists. The cases, in order:
      *   copy      — exact same type (typeEquals), the field/element moves as is
      *   retag     — union into union, every arm mapped (unionRetagMappable —
-     *               identity arms, trap-less; record/array arms may width-lift
-     *               into exactly one destination arm)
+     *               identity arms and compatible payload conversions; a shared
+     *               discriminant may select different record destinations)
      *   wrap      — a non-unit arm value into a union that contains it
+     *   discriminantWrap — identical recursive layouts distinguished by
+     *               their literal field value rather than their storage id
      *   liftWrap  — a record/array value into a union with NO identical arm
      *               but exactly ONE arm it width-lifts into (the findRoute
      *               rule applied at every level; several candidates are
@@ -1409,6 +1357,13 @@ export declare class Lowerer {
      * lift needs (planned first, so the interns cannot fail — a failure here
      * is a lowerer bug, not a user diagnostic). */
     applyWidthLift(lift: WidthLift, value: IrExpr, dst: IrType, loc: SrcLoc): IrExpr;
+    /** Dispatch a structural copy from its runtime union tag. Each record
+     * payload has its own field offsets and optional-field completions;
+     * interpreting all arms as the destination layout would corrupt memory.
+     * Intern before descending so recursive record unions can reuse it. */
+    unionRecordWidthHelper(fromId: string, target: IrType & {
+        kind: "record";
+    }, loc: SrcLoc): string;
     /** Interned `%rec.width.<n>(r)` — builds the target shape from a source
      * record by copying fields: every target field must exist on the source
      * with the EXACT same type, or with a type that LIFTS under
@@ -1612,28 +1567,9 @@ export declare class Lowerer {
     }, toT: IrType & {
         kind: "func";
     }, loc: SrcLoc): string | null;
-    /** Interned `%union.retag.<n>(u)` — the runtime re-tag for a value of
-     * union `fromId` flowing into a slot of union `toId`: a switch on the
-     * source tag re-wraps the payload under its tag in the destination
-     * (unionNarrow + unionWrap — the payload pointer moves, no copy, so
-     * ref-arm identity is preserved across the re-tag). Arms map by
-     * canonical type (typeEquals): every non-unit source arm must exist in
-     * the destination, or the pair isn't mappable (null — the caller keeps
-     * the SC2003 fence). A stranded UNIT arm (undefined/null with no
-     * destination arm) is different: it means tsc's picture at the site was
-     * NARROWER than the IR type — control-flow narrowing to a sub-union, or
-     * a non-null assertion, both of which erase at lowering — so the arm is
-     * exactly the possibility the checker proved (or the source asserted)
-     * away. It compiles to a runtime trap case throwing a catchable
-     * TypeError-shaped string, the lying-cast stance (SEMANTICS.md): sound
-     * narrowing never reaches it, a lying `!` throws instead of smuggling
-     * an unrepresentable unit into the destination. */
-    /** True when unionRetagHelper can bridge the pair — every non-unit
-     * source arm exists (typeEquals) in the destination, or width-lifts
-     * into exactly one destination arm (widthLiftPlan — record and array
-     * arms compose the re-tag with the per-arm reshape). Pure: callers that
-     * must validate a WHOLE plan before interning anything (recordWidthHelper)
-     * probe with this so a failed later field never orphans a helper. */
+    /** Validate the complete union conversion before interning helpers.
+     * Recursive width plans close through the same in-progress pair guard;
+     * no optimistic result is memoized after that planning stack unwinds. */
     unionRetagMappable(fromId: string, toId: string): boolean;
     /** A checker-NARROWED union flowing into a different union: `typeof r
      * === "string" || Buffer.isBuffer(r)` proves the record arm of r away,
@@ -1670,6 +1606,9 @@ export declare class Lowerer {
     strandedCoercionTrap(expr: IrExpr, expected: IrType & {
         kind: "union";
     }, loc: SrcLoc): IrExpr | null;
+    recordUnionWrapHelper(source: IrType & {
+        kind: "record";
+    }, toId: string, loc: SrcLoc): string | null;
     unionRetagHelper(fromId: string, toId: string, loc: SrcLoc, trappable?: ReadonlySet<number>): string | null;
     /** Interned `%union.narrow.<n>(u)` — the CHECKED single-arm extraction
      * behind `x!` on union values: the asserted arm's payload comes out
@@ -1753,13 +1692,16 @@ export declare class Lowerer {
      * `var` read before its unit-initialized statement holds undefined —
      * also a unit — so the mixed case reports both names. */
     provenUnitAnyOf(node: ts.Node, value: IrExpr): string | null;
-    /** Lowers an expression that flows into a slot of a known expected type,
-     * then applies the coercion path (coerceInto). An EMPTY array literal
-     * takes the slot's array type directly — the caller-supplied `expected`
-     * lowerArrayLiteral documents, for the positions where tsc's contextual
-     * API answers nothing (binding-element defaults: `{ json = [] }`) and
-     * the literal's own never[] would build the f64 representation. */
+    /** A key conversion may rebox or upcast a reference, but must never copy
+     * its referent. Apply the ordinary checked narrowing to absent arms from
+     * runtime-optional reads; only present reference arms participate here. */
+    lowerCollectionKey(node: ts.Expression, expected: IrType): IrExpr;
+    /** Lower for a known destination, then apply ordinary value coercion.
+     * Fresh arrays and records use the destination layout directly. */
     lowerExprExpecting(node: ts.Expression, expected: IrType | undefined): IrExpr;
+    /** An unannotated empty collection has no existing elements or aliases
+     * that constrain its layout. An explicit type argument still wins. */
+    emptyCollectionFor(node: ts.Expression, expected: IrType): IrExpr | null;
     /** A value flowing into an index-signature VALUE slot (an overflow
      * literal entry, a dynamic-keyed record write). dyn slots (`unknown`
      * signatures — ModelPricing's) take a dyn conversion: dyn values pass
@@ -1876,8 +1818,8 @@ export declare class Lowerer {
         context: string;
         ordinal: number;
     }): void;
-    lowerClassExpressionInfo(expr: ts.ClassExpression): ClassInfo;
-    lowerClassExpression(expr: ts.ClassExpression): IrExpr;
+    lowerClassExpressionInfo(expr: ts.ClassLikeDeclaration): ClassInfo;
+    lowerClassExpression(expr: ts.ClassLikeDeclaration): IrExpr;
     findMethodOn(info: ClassInfo | null, name: string): {
         declarer: ClassInfo;
         sig: {
@@ -1885,6 +1827,7 @@ export declare class Lowerer {
             ret: IrType;
             abstract?: true;
             async?: true;
+            gen?: NonNullable<IrFunction["generator"]>;
         };
     } | null;
     isSubclassOf(sub: string, sup: string): boolean;
@@ -1900,15 +1843,20 @@ export declare class Lowerer {
      * members ride fp.classDecls; expressions register only when their
      * containing statement lowers). */
     readonly exprClasses: ClassInfo[];
-    readonly exprClassInfoByNode: Map<ts.ClassExpression, ClassInfo>;
+    readonly exprClassInfoByName: Map<string, ClassInfo>;
     /** Class expressions whose collection is IN FLIGHT — the reentrancy
      * guard for heritage-demanded collection (lowerClassExpressionInfo). */
-    readonly collectingExprClasses: Set<ts.ClassExpression>;
+    readonly collectingExprClasses: Set<ts.ClassLikeDeclaration>;
     /** Static-init statements of class expressions inside the statement
      * currently lowering — lowerFileInit drains the buffer immediately
      * BEFORE that statement (JS's order for the supported whole-initializer
      * positions). */
     readonly pendingClassExprInits: IrStmt[];
+    readonly computedClassBases: Map<string, {
+        value: IrExpr;
+        classInfo: ClassInfo;
+    }>;
+    readonly computedCallableBases: Map<ts.ClassLikeDeclaration, IrExpr>;
     /** Discovery hook: registers a just-collected expression class's member
      * bodies as worklist units (the units map is otherwise built before
      * lowering starts). Null in the emit pass. */
@@ -1916,7 +1864,7 @@ export declare class Lowerer {
     /** Mixin functions (`(Base: T) => class extends Base {…}`) by their
      * function-like node: recognized shape, or null for checked
      * non-qualifiers (lower-mixins.ts). */
-    readonly mixinFnShapes: Map<ts.Node, MixinFnShape | null>;
+    readonly mixinFnShapes: Map<import("../ts7/ast-node.js").AstNode, MixinFnShape | null>;
     /** Mixin instantiations by CALL SITE (one class per once-evaluated call
      * — the class-expression identity rule); null marks a poisoned
      * instantiation so re-demands fence instead of half-collecting. */
@@ -1955,7 +1903,7 @@ export declare class Lowerer {
      * onExprClassCollected should instantiations ever need eager
      * registration. */
     onLateClassCollected: ((info: ClassInfo) => void) | null;
-    genericClassInstanceType(decl: ts.ClassLikeDeclaration, ref: ts.Type): IrType | null;
+    genericClassInstanceType(decl: ts.ClassLikeDeclaration, ref: ts.Type, mapArgument?: (type: ts.Type) => IrType | null): IrType | null;
     findStaticOn(info: ClassInfo | null, name: string): ReturnType<typeof findStaticOn>;
     staticShadowBelow(info: ClassInfo, name: string): boolean;
     ctorAbiEquals(sub: ClassInfo, sup: ClassInfo): boolean;
@@ -1974,8 +1922,8 @@ export declare class Lowerer {
     fieldInitStmts(info: ClassInfo, thisLocal: IrLocal): IrStmt[];
     lowerDerivedCtorBody(info: ClassInfo, thisLocal: IrLocal, forward?: IrExpr[]): IrStmt[];
     superCallStmt(info: ClassInfo, thisLocal: IrLocal, args: IrExpr[], loc: SrcLoc): IrStmt;
-    /** Declares the `this` param local, registered under the THIS_BINDING
-     * sentinel so lexical-this capture in arrows uses the normal machinery. */
+    /** Declares the this parameter in the function's dedicated binding slot.
+     * Arrow captures use the same boxing and threading as named bindings. */
     declareThis(type: IrType): IrLocal;
     lowerFunction(decl: ts.FunctionDeclaration): IrFunction | null;
     collectGlobals(sf: ts.SourceFile, topStmts: ts.Statement[]): void;
@@ -2008,7 +1956,7 @@ export declare class Lowerer {
     };
     /** The binding for `symbol` inside context `ctx` — a scoped local or an
      * already-threaded capture entry. */
-    bindingIn(ctx: FnCtx, symbol: ts.Symbol): IrLocal | null;
+    bindingIn(ctx: FnCtx, symbol: ts.Symbol | undefined): IrLocal | null;
     /** Resolves an identifier to a local of the CURRENT function, creating
      * capture entries (and boxing the origin binding) when the name lives in
      * an enclosing function. Self-references of a named lambda are NOT
@@ -2026,7 +1974,7 @@ export declare class Lowerer {
      * the REAL lowering path still resolves (and diagnoses) the reference
      * itself. */
     peekLocal(ident: ts.Identifier): IrLocal | null;
-    resolveKey(symbol: ts.Symbol, blame?: ts.Node): IrLocal | null;
+    resolveKey(symbol: ts.Symbol | undefined, blame?: ts.Node): IrLocal | null;
     isSelfReference(ident: ts.Identifier): boolean;
     lowerStmts(stmts: readonly ts.Statement[]): IrStmt[];
     noteBlockedBindings(stmt: ts.Statement): void;
@@ -2100,7 +2048,9 @@ export declare class Lowerer {
     }) | (IrType & {
         kind: "record";
     })): IrExpr;
-    lowerObjectLiteral(expr: ts.ObjectLiteralExpression): IrExpr;
+    lowerObjectLiteral(expr: ts.ObjectLiteralExpression, expected?: IrType & {
+        kind: "record";
+    }): IrExpr;
     lowerShorthandValue(prop: ts.ShorthandPropertyAssignment): IrExpr;
     rejectThisInObjectMethod(node: ts.Node): void;
     lowerElementAccess(expr: ts.ElementAccessExpression): IrExpr;
@@ -2117,7 +2067,7 @@ export declare class Lowerer {
     caughtToString(node: ts.Expression): IrExpr | null;
     lowerInstanceOf(expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
     private withRuntimeOptionalClassValue;
-    private withExpressionOverride;
+    withExpressionOverride<T>(node: ts.Expression, value: IrExpr, lower: () => T): T;
     lowerCall(expr: ts.CallExpression): IrExpr;
     isTopLevelFnSymbol(ident: ts.Identifier): boolean;
     lowerNestedFunctionDecl(stmt: ts.FunctionDeclaration): IrStmt;
@@ -2164,7 +2114,7 @@ export declare class Lowerer {
     fieldGetExpr(target: FieldTarget, loc: SrcLoc, blame: ts.Node): IrExpr;
     fieldSetStmt(target: FieldTarget, value: IrExpr, loc: SrcLoc, blame: ts.Node): IrStmt;
     lowerFieldCompound(access: ts.PropertyAccessExpression | ts.ElementAccessExpression, op: CompoundOp, rhsNode: ts.Expression | null, loc: SrcLoc): IrStmt;
-    errorMessageArg(args: readonly ts.Expression[], loc: SrcLoc, blame: ts.Node): IrExpr;
+    errorConstructorArgs(args: readonly ts.Expression[], loc: SrcLoc, blame: ts.Node): IrExpr[];
     inheritsBuiltinErrorCtor(info: ClassInfo): boolean;
     inheritsBuiltinEmitterCtor(info: ClassInfo): boolean;
     lowerNew(expr: ts.NewExpression): IrExpr;
@@ -2225,6 +2175,7 @@ export declare class Lowerer {
         module: string;
         member: string;
     }, loc: SrcLoc): IrExpr | null;
+    lowerNativeCallableValue(fn: BuiltinModuleFn, display: string, loc: SrcLoc): IrExpr | null;
     isBuiltinCallableValue(expr: IrExpr): boolean;
     lowerBuiltinModuleCall(expr: ts.CallExpression, bi: {
         module: string;
@@ -2332,4 +2283,3 @@ export declare class Lowerer {
     islandGlobalFnOf(ident: ts.Identifier): IslandFnEntry | null;
     lowerIslandMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 }
-export {};