@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -1,4 +1,9 @@
+import type { DiagnosticCode } from "../../diagnostics/codes.js";
+import { type RecordOrigin } from "./decl-origin.js";
+import { type JournalScalar, type JournalTable, type UnitEvents } from "./unit-journal.js";
 import { StructuralPositions } from "./structural-positions.js";
+import { type NodeIslandSet } from "../../node-islands/boundary.js";
+import type { IslandModuleBinding } from "./lower-node-island.js";
 import type { ConstructorReturnPlan } from "./constructor-returns.js";
 import { type CycleInitFlag } from "./cycle-initialization.js";
 import { type JsonRequireModule } from "./json-require.js";
@@ -26,7 +31,8 @@ export type { WidthLift } from "./width-lift.js";
 export { newFnCtx, type FnCtx } from "./function-context.js";
 import * as ts from "../ts7/adapter.js";
 import { type UnionLiteral } from "../union-discriminants.js";
-import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
+import type { ScrDiagnostic, TypeFailure, TypeFailureSlot } from "../../diagnostics/diagnostic.js";
+import { type DynamicSlotEntry } from "../../diagnostics/dynamic-slots.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 StartupCrash, type CycleEdge } from "../program.js";
@@ -41,15 +47,39 @@ import { type ParamShape, type FnSig } from "./call-signatures.js";
 import { type GenericFnInfo, type GenericInstance } from "./generic-functions.js";
 import type { InstantiationPath } from "./instantiation-path.js";
 import { type ArrayHofInfo } from "./containers/array-pipelines.js";
+import { type RecordOvfCapturePlan } from "./containers/indexed-objects.js";
 import { type ComputedEventPattern, type EmitSpecCtx, type EmitSpecRequest, type EventSig } from "./lower-event-emitter.js";
 import { type ConsoleMethodMember, type ConsoleOutputMember } from "./builtins/console.js";
 import type { AssertInstanceOptions } from "./assert-instances.js";
 import { type FieldTarget } from "./lower-exprs.js";
 import type { ExpandoMembers } from "./lower-expando.js";
+import { NodeIslandModuleCollector } from "../../node-islands/modules.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";
+/** A slot the localized-failure commit points turned into a checked
+ * dynamic slot (SC6104): where it is, what its declared type is, and the
+ * diagnostic it would have failed with. */
+export interface DynamicSlot {
+    loc: SrcLoc;
+    failure: TypeFailure;
+    code: string;
+    reason: string;
+    /** The slot keeps its type's compilable shape; only the failing
+     * components are checked-dynamic (push-down, stage L3). */
+    partial?: true;
+    /** The type mapped exactly from its canonical form (stage N2): a static
+     * slot, never reported as dynamic. */
+    canonical?: true;
+}
 export declare class PoisonError extends Error {
+    /** Set when a type with no static lowering poisoned a slot (badType and
+     * the dyn class field policy): what failed, for the localized-failure
+     * commit points. Report-only in stage L0. */
+    readonly failure: TypeFailure | undefined;
+    /** The checker type that failed (with `failure`). */
+    readonly failedType: ts.Type | undefined;
+    constructor(failure?: TypeFailure, failedType?: ts.Type);
 }
 /** A function-shaped value that exists only in the compiler's static
  * projection graph. Declared-function aliases point at the original
@@ -141,6 +171,9 @@ export interface LowerResult {
     /** Performance warnings (SC61xx): the likely-hot functions the source
      * leaves untyped (lowering/dynamic-tier.ts). Never failures. */
     performance?: ScrDiagnostic[];
+    /** Localized failure: the checked dynamic slots the commit points
+     * created (each also an SC6104 in `performance`), present when any. */
+    dynamicSlots?: DynamicSlotEntry[];
     /** Functions lowering placed in the dynamic tier (ir/tiers.ts), present
      * when there are any. */
     dynamicFunctions?: DynamicFunction[];
@@ -148,6 +181,9 @@ export interface LowerResult {
     tiers?: TierReport;
 }
 export interface LowerOptions {
+    /** Packages that run in Node islands (scope-B NI-4): their imports lower
+     * to island loads and their values to island handles. */
+    nodeIslands?: NodeIslandSet | null;
     /** Parser/checker services owned by the load; required for npm graph analysis. */
     frontendServices?: FrontendServices | undefined;
     /** The project's tsconfig sets `checkJs` (see isCheckedJsSourceFile). */
@@ -175,6 +211,8 @@ export interface LowerOptions {
     inlineRequireCycleCalls?: ReadonlySet<ts.Node> | undefined;
     /** LoadResult.moduleEdges. */
     moduleEdges?: ReadonlyMap<ts.SourceFile, readonly CycleEdge[]> | undefined;
+    /** LoadResult.dynamicImportRejections. */
+    dynamicImportRejections?: ReadonlyMap<ts.SourceFile, StartupCrash> | undefined;
     /** LIBRARY mode's reachability roots: the profile-mapped exports of the
      * entry module. Executable builds root at the entry's top level alone
      * (an unreferenced export dead-strips); a library's exports are called from
@@ -210,7 +248,7 @@ export interface LowerOptions {
     };
 }
 interface RuntimeFenceFallback {
-    code: `SC${number}`;
+    code: DiagnosticCode;
     message: string;
 }
 interface RuntimeFenceBase {
@@ -239,11 +277,32 @@ interface RuntimeFenceClosureTarget extends Omit<RuntimeFenceFunctionTarget, "ki
         kind: "func";
     };
 }
+/** A degraded checker type (Lowerer.degradedTypes): its lenient mapping and
+ * the failure that degraded it. */
+export interface DegradedType {
+    lenient: IrType | null;
+    code: string;
+    reason: string;
+    /** The type maps exactly from its canonical form (stage N2): its slots
+     * are static. */
+    canonical?: true;
+}
 /** The Lowerer's pass configuration (see lowerToIr). */
 export interface LowererMode {
     /** Symbols whose deferred diagnostics reachable emit already flushed —
      * the remainder must not report them a second time. */
     alreadyFlushed?: ReadonlySet<ts.Symbol>;
+    /** Localized failure: the types reachable emit degraded (the coverage
+     * remainder maps them alike, so the declarations reachable emit
+     * registered with dynamic slots collect there too). */
+    degradedTypes?: ReadonlyMap<number, DegradedType>;
+    /** Localized failure: the declarations reachable emit registered with
+     * dynamic slots (the coverage remainder registers them too). */
+    retriedSymbols?: ReadonlySet<ts.Symbol>;
+    /** Localized failure: degrade every type to the whole-slot checked
+     * dynamic, never to its pushed-down shape (lowerToIr's comparison
+     * pass). */
+    wholeSlotDegradation?: boolean;
     /** LowerOptions.externalTypes, threaded through every lowering pass. */
     externalTypes?: ReadonlyMap<string, string>;
     /** LowerOptions.externalTypeSpecifiersByFile, shared by every pass. */
@@ -267,6 +326,8 @@ export interface LowererMode {
     dynNodeStreams?: boolean;
     /** LoadResult.inlineRequireCycleCalls. */
     inlineRequireCycleCalls?: ReadonlySet<ts.Node> | undefined;
+    /** LoadResult.dynamicImportRejections. */
+    dynamicImportRejections?: ReadonlyMap<ts.SourceFile, StartupCrash> | undefined;
     /** LowerOptions.libraryCallbacks (see there). */
     libraryCallbacks?: boolean;
     projectCheckJs?: boolean;
@@ -329,7 +390,25 @@ export declare function dynFallbackType(lowerer: Lowerer, node: ts.Node, t: ts.T
  * their own name, anonymous function/arrow expressions their
  * NamedEvaluation home (a variable initializer or property assignment).
  * Null when nothing names the value (the box stays anonymous). */
+/** The name Node gives the builtin module function `node` reads, through
+ * const aliases (`const get = process.cwd`), when the module table names its
+ * value differently from its member (BuiltinModuleFn.valueName); else null. */
+export declare function builtinValueNameOf(node: ts.Node, lowerer: Lowerer): string | null;
 export declare function jsFuncNameOf(node: ts.Node, lowerer?: Lowerer): string | null;
+/** A loop over an untyped iterable (lowerForOfDyn). `kind` is a local the
+ * loop sets once it has opened the iterator: 0 for the dynamic protocol,
+ * or the 1-based index of the program's generator type it steps natively.
+ * `value` is the per-step local whose initializer takes one step. */
+export interface UntypedLoopSite {
+    kind: string;
+    value: string;
+    iterator: string;
+    next: string;
+    done: string;
+    /** `for await`; `sync` names its async-from-sync flag. */
+    async: boolean;
+    sync: string | null;
+}
 export declare class Lowerer {
     readonly program: ts.Program;
     readonly entry: ts.SourceFile;
@@ -347,11 +426,22 @@ export declare class Lowerer {
     /** Inline require() calls whose module edge closes a require cycle
      * (LoadResult.inlineRequireCycleCalls). */
     readonly inlineRequireCycleCalls: ReadonlySet<ts.Node>;
+    /** LoadResult.dynamicImportRejections. */
+    readonly dynamicImportRejections: ReadonlyMap<ts.SourceFile, StartupCrash>;
     /** Immutable callable aliases and compiler-generated adapters. The map
      * is symbol-keyed, so shadowing and cross-module imports keep the same
      * exact binding discipline as globals/functions. */
     readonly staticCallables: Map<ts.Symbol, StaticCallableProjection>;
     readonly genericFnsBySymbol: Map<ts.Symbol, GenericFnInfo>;
+    /** Typed declarations' instances for arguments that keep their own
+     * record or array layout (structural-instances.ts). */
+    readonly structuralFnInfos: Map<ts.Symbol, GenericFnInfo>;
+    /** Consts that keep their initializer's record or array layout, with the
+     * initializer's checker type (structural-instances.ts). */
+    readonly preservedLayoutTypes: Map<ts.Symbol, ts.Type>;
+    /** Arguments and const initializers whose array or record layout the
+     * lowering kept instead of copying (divergences.ts reports no copy there). */
+    readonly layoutKeptNodes: Set<import("../ts7/ast-node.js").AstNode>;
     /** Object-literal GENERIC methods (`{ m<T>(x: T) {...} }`), interned by
      * their function-like node — instances ride the same monomorphization
      * queue (objLitGenericFnInfoOf). */
@@ -499,6 +589,23 @@ export declare class Lowerer {
      * the body needs — indexed accesses (`T[K]` needs K's literal key) and
      * keyed record reads (`o[k]` where k's type is a literal-bound K). */
     typeParamTsBindings: Map<ts.Symbol, ts.Type> | null;
+    /** Generic alias references of call-keyed instances' declared signatures
+     * (`Catalog<G, P>`), each with the same alias as every call's resolved
+     * signature instantiates it (`Catalog<{ g1: … }, "acme">`), together with
+     * that instance's ts-level bindings map (typeParamTsBindings), which every
+     * scope that lowers the instance installs. The checker keeps the alias
+     * symbolic inside the generic body and offers no way to instantiate it
+     * with the bound arguments, but alias instantiations are interned: the
+     * body's `x as Catalog<G, P>` is the very type the signature declares, so
+     * the pair recorded during unification is that re-instantiation. */
+    readonly boundAliasInstances: Map<ts.Type, {
+        tsBindings: Map<ts.Symbol, ts.Type>;
+        instance: ts.Type;
+    }[]>;
+    /** Values an erased type assertion produced, with the asserted type
+     * (`x as T` keeps x's representation): a slot that no ordinary
+     * conversion reaches converts them as asserted (assertedConversion). */
+    readonly assertedValues: Map<IrExpr, IrType>;
     /** Non-null while an IMPLICIT-ANY instance body lowers (npm-static JS;
      * see generic-functions.ts): bound param symbol →
      * the call site's checker type, consulted by typeOf for identifier
@@ -669,6 +776,11 @@ export declare class Lowerer {
     /** for-of loops over arrays that can hold neither holes nor undefined:
      * each pass reads the element payload directly. */
     readonly presentElementLoops: Set<ts.ForOfStatement>;
+    /** Element keys (typeKey of the element type) of native arrays that can
+     * hold elements outside their element type, stored through dynamic views
+     * (SCR_ARR_FOREIGN); "*" for every array. Empty unless the program stores
+     * values through a dynamic value that can view a native array. */
+    foreignElementKeys: ReadonlySet<string>;
     /** The fs/promises glob() call lowerForOf is lowering as a for await
      * head; other glob() calls have no lowering. */
     fspGlobHead: ts.Node | null;
@@ -678,6 +790,18 @@ export declare class Lowerer {
     runtimeOptionalRootOf(local: IrLocal): IrLocal;
     runtimeOptionalBindingType(node: ts.Node): IrType | null;
     runtimeOptionalBindingType(node: ts.Node, fallback: IrType): IrType;
+    /** An object or array literal in an untyped context: its contextual type
+     * is `unknown` or `any` from a slot the program declares (a variable,
+     * field, parameter, return type or `unknown[]` element; a library
+     * parameter typed `any` only through a type argument), it is thrown, or
+     * it is a member of such a literal, and it holds data only (no methods,
+     * accessors or function members). Its value is built as a dynamic
+     * object: no type the program wrote gives it a native layout, and a later
+     * checked cast adopts it (dyn.adoptShared), so every holder keeps one
+     * identity. A library parameter the declarations type `any` or `unknown`
+     * itself (`console.log`, `JSON.stringify`) only reads the value and keeps
+     * the native literal. */
+    untypedLiteralContext(x: ts.Expression): boolean;
     /** A fresh TypeScript data literal (`{ message: "m" }`) passed to a
      * checked-dynamic parameter of a callee implemented in JavaScript, whose
      * contract lets it reshape the object: a call through an untyped value, an
@@ -879,6 +1003,19 @@ export declare class Lowerer {
      * checks resolve through this map (stdlibGlobalNameOf), declarations
      * emit nothing. */
     readonly stdlibGlobalAliases: Map<ts.Symbol, string>;
+    /** The TypeScript declarations registered in stdlibGlobalAliases: the
+     * global each one names and its own name node. Their declarations emit
+     * nothing, so a read that needs the VALUE reports at the declaration
+     * (stdlibGlobalAliasDecl, rejectUnresolvedSymbol) instead of compiling
+     * it away. An unread snapshot stays elided: reading a global has no
+     * side effects. */
+    readonly stdlibGlobalAliasDecls: Map<ts.Symbol, {
+        alias: string;
+        name: ts.Identifier;
+    }>;
+    /** Snapshots whose declaration-side refusal already reported (one
+     * declaration, one report). */
+    private readonly stdlibSnapshotReported;
     /** The stdlibGlobalAliases bound through a cast of the global object
      * (`(globalThis as { Buffer?: B }).Buffer`). Their static type is the
      * cast's, so their value reads are refused (identifiers.ts). */
@@ -997,6 +1134,9 @@ export declare class Lowerer {
     /** The property names the program assigns on the global object
      * (property-access.ts), collected on first use. */
     globalThisWrittenNames: Set<string> | null;
+    /** Set with globalThisWrittenNames: the program writes the global object
+     * by a computed name somewhere. */
+    globalThisComputedWrite: boolean;
     /** Well-known symbol methods (`sym:iterator`) the program may replace
      * through a symbol-keyed write: an instance or prototype property, or a
      * reflection call. */
@@ -1011,6 +1151,8 @@ export declare class Lowerer {
     /** 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>;
+    /** Methods of checked-JavaScript override pairs (vtable dispatch). */
+    readonly checkedJsOverrideMethods: Set<ts.MethodDeclaration>;
     /** Descendant writes must widen the original JS field before collecting
      * any class layout; base and derived instances share its storage ABI. */
     readonly inheritedJsFieldWrites: Map<ts.ClassDeclaration | ts.ClassExpression, Map<string, ts.ExpressionBase[]>>;
@@ -1056,6 +1198,9 @@ export declare class Lowerer {
     } | {
         kind: "static-builtin";
         module: string;
+    } | {
+        kind: "rejected";
+        crash: StartupCrash;
     }>;
     readonly createRequireImports: Map<string, "" | {
         entryKey: string;
@@ -1120,6 +1265,47 @@ export declare class Lowerer {
     usesWasmCustomSections: boolean;
     /** The program constructs a LifetimeRegion (lifetime-regions.ts). */
     usesLifetimeRegions: boolean;
+    /** The program calls into Node.js (@scriptc/node): the module carries
+     * the nodeIsland record, which the executable build fills in. */
+    usesNodeIsland: boolean;
+    /** The program's Node island packages (scope-B NI-4), or null. */
+    readonly nodeIslands: NodeIslandSet | null;
+    /** Island module loads, by the importing file and specifier: the module
+     * global holding what the import form sees (lower-node-island.ts). */
+    readonly islandModules: Map<string, IslandModuleBinding>;
+    /** The modules Node island calls load (lower-node-island.ts). */
+    readonly nodeIslandModules: NodeIslandModuleCollector;
+    /** Each call's caller literal, set to its tree path when lowering ends. */
+    readonly nodeIslandCallers: {
+        literal: IrExpr & {
+            kind: "strLit";
+        };
+        caller: string;
+    }[];
+    /** Absolute specifiers, rewritten to the shipped file relative to their caller. */
+    readonly nodeIslandSpecifiers: {
+        literal: IrExpr & {
+            kind: "strLit";
+        };
+        caller: string;
+        target: string;
+    }[];
+    /** Each island module load's path literal, set to its tree path when lowering ends. */
+    readonly nodeIslandLoads: {
+        literal: IrExpr & {
+            kind: "strLit";
+        };
+        path: string;
+    }[];
+    /** Island handle bindings by symbol (lower-node-island.ts). */
+    readonly islandHandleBindings: Map<ts.Symbol, boolean>;
+    /** `instanceof` expressions the island lowering already handles. */
+    readonly islandInstanceofHandled: Set<import("../ts7/ast-node.js").AstNode>;
+    /** NI-6: the modules shared with Node islands (lower-shared-modules.ts),
+     * their SC8020 warnings, and the TDZ flags their declarations set. */
+    sharedModules: import("./lower-shared-modules.js").SharedModulePlan[] | null;
+    readonly sharedModuleWarnings: ScrDiagnostic[];
+    readonly sharedInitFlags: Map<ts.StatementBase, string[]>;
     /** Per-directory answers of experimental-import.ts's declaration-file test. */
     readonly experimentalFiles: Map<string, boolean>;
     /** Interned LifetimeRegion.run helpers, by callback type key. */
@@ -1203,10 +1389,9 @@ export declare class Lowerer {
      * tag. */
     readonly unions: UnionRegistry;
     /** Context-free successful type mappings. See TypeMapperCtx.typeMemo. */
-    readonly typeMemo: Map<string, IrType>;
+    readonly typeMemo: Map<number, IrType>;
     readonly ambient: string;
     readonly overridesAmbient: string;
-    readonly fallbackAmbient: string;
     /** The one mapType context: registries + hooks, assembled in the
      * constructor (typeParamResolver reads the CURRENT instantiation bindings
      * through `this`, so the same ctx serves generic bodies too). */
@@ -1228,6 +1413,23 @@ export declare class Lowerer {
      * values other than fresh literals (noteUntypedIntegrity). */
     untypedIntegrity: boolean;
     readonly liftedFns: IrFunction[];
+    /** `for … of` and `for await` loops over untyped iterables, by their
+     * generator-kind local (generator-dynamic-dispatch.ts steps the program's
+     * own generators there on the typed path). Local ids repeat across
+     * functions; the local itself is in its function's locals. */
+    readonly untypedLoops: Map<IrLocal, UntypedLoopSite>;
+    /** global-values.ts's answer per JavaScript source: the receiver of its
+     * first read of the global object by a computed name, or null. */
+    readonly computedGlobalReads: Map<ts.SourceFile, ts.ExpressionBase | null>;
+    /** global-values.ts's answer per JavaScript source: the builtin globals
+     * its sloppy-mode functions read through their `this`. */
+    readonly sloppyThisGlobalReads: Map<ts.SourceFile, ReadonlySet<string>>;
+    /** global-values.ts's answer: the names the program's global lookup
+     * answers; undefined until asked. */
+    globalLookupNames: readonly string[] | undefined;
+    /** web-streams-dyn.ts's answer: whether a JavaScript source names a web
+     * stream class; undefined until asked. */
+    namesWebStreamClass: boolean | undefined;
     /** The first lifted function of each name (liftedFnNamed), for the
      * liftedFns indexed so far. liftedFns only grows. */
     private readonly liftedFnsByName;
@@ -1250,8 +1452,11 @@ export declare class Lowerer {
      * names do not depend on where the program sits, default library files
      * by their base name (two checkers install them in different
      * directories), and the files scriptc ships by their name inside scriptc,
-     * so names do not depend on where scriptc is installed either. */
+     * so names do not depend on where scriptc is installed either. Relative
+     * paths use `/` on every platform. */
     readonly positions: StructuralPositions;
+    /** The name of `sf` in positions and module tags. */
+    stableFileName(sf: ts.SourceFile): string;
     /** The outermost node whose token span is exactly `loc`, or null. */
     nodeAtLoc(loc: SrcLoc): ts.Node | null;
     /** The lowering unit whose name scopes the closures it lifts. */
@@ -1334,6 +1539,14 @@ export declare class Lowerer {
      * promise operand (returnedPromiseAwait). */
     private returnAwaitedPromise;
     private readonly virtualEdges;
+    /** The events of the unit being recorded (unit-journal.ts); null
+     * otherwise. */
+    unitEvents: UnitEvents | null;
+    /** Fields added to collected classes (class-attributes.ts) and reachable
+     * units registered while units lower: a unit that changes either has no
+     * record (journalScalars). */
+    classLayoutChanges: number;
+    unitRegistrations: number;
     classCanBeConstructed(info: ClassInfo): boolean;
     /** How many classes classCanBeConstructed admits by name, or -1 while
      * it admits every class. The count only grows. */
@@ -1356,6 +1569,20 @@ export declare class Lowerer {
     /** The first lifted function named `name`, the one
      * `liftedFns.find((fn) => fn.name === name)` returns. */
     liftedFnNamed(name: string | undefined): IrFunction | undefined;
+    /** The tables lowering a unit can grow (unit-journal.ts): the
+     * appendable tables whose entries a unit's record carries, then the
+     * tables whose growth leaves the unit without a record.
+     * Lowerer.unjournaled lists the collections that are in neither. */
+    journalTables(): JournalTable[];
+    /** The fields a unit's record need not carry: settings, caches of
+     * program facts that are computed again when needed, state of the unit
+     * being lowered (keyed by its own IR, nodes or frames), scratch that
+     * unwinds before the unit ends, and state that applying the unit's events
+     * rebuilds. */
+    static readonly unjournaled: readonly string[];
+    /** The fields a unit must leave as they were, and the flags it may set
+     * (unit-journal.ts). */
+    journalScalars(): JournalScalar[];
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
      * and no module is built. */
     readonly remainder: boolean;
@@ -1414,6 +1641,64 @@ export declare class Lowerer {
      * the fallthroughs report the inherited-blocker cascade (SC2004)
      * instead of misattributing the reference. */
     readonly blockedBindings: Set<ts.Symbol>;
+    /** Localized failure, report-only: the failure group (type-failure.ts)
+     * of each declaration whose rejection reached the build — a flushed
+     * deferred declaration, or a binding of a poisoned declaration
+     * statement. */
+    readonly rejectedGroups: Map<ts.Symbol, string>;
+    /** One frame per statement lowerStmts is lowering: the failure groups
+     * its lowering touched. A statement that then poisons attributes its
+     * diagnostics to them (ScrDiagnostic.cause). */
+    readonly failureTouches: Set<string>[];
+    /** Localized failure: checker types (by id) whose strict mapping failed
+     * at a committed slot, with their lenient mapping. Filled only at the
+     * commit points (degradeAtCommit), so a program that compiles today
+     * never fills it. */
+    readonly degradedTypes: Map<number, DegradedType>;
+    /** A pushed-down (partial) degraded type was mapped (hasPartialDegradedTypes). */
+    private partialDegradedTypesMapped;
+    /** The components lenient mappings turned into the checked dynamic, by
+     * checker type id, with the declared type they are pieces of (SC6101
+     * causes and per-slot operation counts). */
+    readonly lenientPieces: Map<number, string>;
+    /** One frame per unit a commit point may retry: the pushed-down
+     * (partial) degraded types its lowering mapped (withPartialHits). */
+    readonly partialHits: Set<number>[];
+    /** The dynamic slots the commit points created: one SC6104 each. */
+    readonly dynamicSlots: DynamicSlot[];
+    /** Declarations retryDeferred registered. */
+    readonly retriedSymbols: Set<ts.Symbol>;
+    /** LowererMode.retriedSymbols. */
+    readonly priorRetriedSymbols: ReadonlySet<ts.Symbol>;
+    /** LowererMode.wholeSlotDegradation. */
+    readonly wholeSlotDegradation: boolean;
+    /** Bodies run() skipped because their declaration had not registered. */
+    readonly skippedBodies: Set<import("../ts7/ast-node.js").AstNode>;
+    /** Declarations retryDeferred registered, in order: run() lowers the
+     * bodies it had skipped. */
+    readonly retriedDeclarations: ts.Node[];
+    /** Diagnostics of lowering that a statement's retry does not repeat (a
+     * function-local class's member bodies, lowered once and kept):
+     * dropAttemptDiags keeps them. */
+    readonly loweredOnceDiags: Set<ScrDiagnostic>;
+    /** Deferred classes whose static field initializers' place in %init
+     * has been lowered (retryDeferredAtDeclaration): a later flush must not
+     * register them, since their initializers would never run. */
+    readonly staticInitsPassed: Set<ts.Symbol>;
+    /** Deferred declarations' collections, for the flush retry
+     * (retryDeferred). */
+    readonly deferredCollectors: Map<ts.Symbol, {
+        symbolOf: () => ts.Symbol | undefined;
+        collect: () => void;
+    }>;
+    /** True while a flush retry collects a declaration: the dyn class
+     * field policy (dynFieldPolicyFence) is lifted for reached classes. */
+    liftDynFieldPolicy: boolean;
+    /** Collection diagnostics that a flush retry may simply run again (a
+     * derived class whose base had not registered yet). */
+    readonly retriableDiags: Set<ScrDiagnostic>;
+    /** The checker type behind each type failure badType committed. */
+    readonly failedTypes: Map<TypeFailure, ts.Type>;
     /** True while collectProgram runs: resolution helpers must not flush
      * deferred diagnostics (collection itself resolves symbols — extends
      * clauses — and collection order must not decide what reports). */
@@ -1456,11 +1741,36 @@ export declare class Lowerer {
     /** Bumps the per-file attribution counter (no-op unless provenance is
      * active and this is the emit/discovery lane — mirror the CALLER's
      * suppressStats guard, this method only gates remainder). */
-    bumpFileStat(file: string, kind: "total" | "failed"): void;
+    bumpFileStat(file: string, kind: "total" | "failed", by?: number): void;
     /** The program holds the declaration-typed boundary's projection
      * (decl-projection.ts): user-file record and array values crossing into
      * dynamic slots (package parameters) box as live capsules, so a value
      * that comes back through a boundary cast keeps its identity. */
+    /** Origins of package-declared types checked in this program
+     * (decl-origin.ts), by IrModule.declOrigins index. */
+    readonly declOrigins: string[];
+    private readonly declOriginIds;
+    private readonly packageFileMemo;
+    private readonly slotOriginMemo;
+    /** The value whose slot coercion is being lowered, while that value is
+     * in a package file: union extractions built for it carry the slot's
+     * origin in their TypeError. */
+    coercionOriginNode: ts.Node | null;
+    /** Per user file, each declaration-boundary cast's index in source
+     * order (narrowing.ts recordedBoundaryOrigin). */
+    readonly boundaryCastOrder: Map<ts.SourceFile, Map<import("../ts7/ast-node.js").AstNode, number>>;
+    /** The union type of that value: only its own extraction is the slot's. */
+    coercionOriginUnion: string | null;
+    /** While a record projection into a package-declared type builds, the
+     * origin of the field being converted. */
+    coercionFieldOrigin: string | null;
+    private readonly recordOriginMemo;
+    /** The package-declared record type the current coercion converts to. */
+    coercionRecordOrigin(): RecordOrigin | null;
+    declOriginIndex(origin: string): number;
+    /** The origin of the package-declared slot a value flows into. */
+    slotOriginOf(node: ts.Node): string | null;
+    private inPackageFileOf;
     private declBoundaryMemo;
     get declBoundary(): boolean;
     /** Tracked classes' bag initializers over a typed `this`
@@ -1474,6 +1784,9 @@ export declare class Lowerer {
     registerBuiltinErrorClasses(): void;
     private classProtocols;
     classImplementedProtocol(type: ts.Type): boolean;
+    /** A record view a Map or Set answers: it keeps protocol identity but
+     * calls the collection's own methods, never a stored member. */
+    classCollectionView(type: ts.Type): boolean;
     /** Declared class fields may store a DYN value only when its static type
      * is `unknown` or `object` (also with `null` or `undefined`, or an array
      * of those), names checked protocol identity, is an owned runtime
@@ -1506,6 +1819,29 @@ export declare class Lowerer {
         assignedLater: ReadonlySet<string> | "all";
     };
     sourceFileOfModuleNamespace(type: IrType): ts.SourceFile | null;
+    /** A module namespace taken as a checked-dynamic value (`const u: unknown
+     * = ns`, `take(ns)`): the runtime's namespace object — one per module,
+     * Node's sorted export keys, live reads through a compiled getter, and
+     * Node's read-only write errors — built by `moduleNamespaceDynValue`.
+     * `node:` builtins have no compiled source and no complete export table,
+     * so they keep their fence. */
+    moduleNamespaceDyn(ns: IrExpr & {
+        type: IrType & {
+            kind: "moduleNs";
+        };
+    }): IrExpr | null;
+    /** A `Promise<module namespace>` taken as `Promise<unknown>` (or as
+     * `unknown`): one lifted async mapper per module awaits the promise and
+     * answers the same namespace object a bare namespace value boxes to, so
+     * the settlement is Node's namespace while the value stays a promise.
+     * The import() promise reaches these slots alone, and the runtime's
+     * per-module namespace cache keeps `await mapped === await original`; a
+     * rejection propagates unchanged. */
+    moduleNamespacePromiseDynValue(value: IrExpr & {
+        type: IrType & {
+            kind: "promise";
+        };
+    }): IrExpr | null;
     builtinErrorInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
     builtinEmitterInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
     builtinStreamInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
@@ -1597,6 +1933,17 @@ export declare class Lowerer {
      * declaration, or an ESM default import of CommonJS. One resolver keeps
      * member-symbol fallback and namespace classification in lockstep. */
     private localModuleBindingDepOf;
+    private readonly createRequireBindingTargets;
+    private readonly createRequireElementTargets;
+    /** The program module a `const x = createRequire(...)("./m")` binding
+     * requires, by the binding's symbol; null for every other binding. Every
+     * reference resolves it (resolveValueSymbol), so it is cached. */
+    private createRequireBindingTarget;
+    /** The binding element and required program module of a
+     * `const { m } = createRequire(...)("./m")` binding, by the binding's
+     * symbol; null for every other binding. Cached like
+     * createRequireBindingTarget. */
+    private createRequireElementTarget;
     /** The represented single value behind a createRequire binding, or null
      * when the target is a namespace/table module. Collection has already
      * registered executable exports before entry-module uses lower, so the
@@ -1692,6 +2039,9 @@ export declare class Lowerer {
      * percentage would overstate how much of the program compiles. Count
      * every statement the body holds as attempted and failed, in addition to
      * the skipped-function tally. */
+    /** countSkippedBody undone: a flush registered the declaration after
+     * its body was skipped, and the body lowers now. */
+    private uncountSkippedBody;
     private countSkippedBody;
     /** Coverage remainder: the body diagnostics of a function whose
      * signature blocked (blockedBodyDiagnostics). A function reachable emit
@@ -1721,6 +2071,9 @@ export declare class Lowerer {
         reachable: Set<string>;
         result: LowerResult;
     };
+    /** The lowerer's side of a recorded wave (unit-journal.ts).
+     * `lowerUnitBody` lowers a unit as reachable emit does. */
+    private waveHost;
     /** Reachability hook (see emitReachable): fires when lowering resolves a
      * reference to a lowerable body. */
     noteEdge(name: string): void;
@@ -1733,6 +2086,7 @@ export declare class Lowerer {
      * this call site; a virtualCall through their own static classes marks
      * them). */
     noteVirtualEdge(info: ClassInfo, method: string): void;
+    private virtualEdgeOf;
     moduleArtifacts(functions: IrFunction[]): {
         classes: IrClassDef[];
         records: IrRecordShape[];
@@ -1766,19 +2120,105 @@ export declare class Lowerer {
      * the instantiation context is appended so the user knows which concrete
      * types made the (source-anchored) construct fail. */
     pushDiag(diag: ScrDiagnostic): void;
-    unsupported(code: keyof typeof UNSUPPORTED & `SC${number}`, node: ts.Node, featureOverride?: string, hintOverride?: string, reason?: string): never;
+    /** The module's Node island record: the collected module tree, with each
+     * call's caller literal and each load's path literal set to its path in
+     * that tree. The executable build fills in the libnode pack (index.ts). */
+    private nodeIslandRecord;
+    unsupported(code: keyof typeof UNSUPPORTED & DiagnosticCode, node: ts.Node, featureOverride?: string, hintOverride?: string, reason?: string): never;
     externalHostFence(specifier: string, node: ts.Node, valueUse?: boolean): never;
     anyOpFence(feature: string, node: ts.Node): never;
     /** True when this expression's CHECKER type is `any`-flavored — the
      * gate anyOpFence's call sites use to tell `any`-origin dyn values
      * with an unsupported operation from genuine `unknown` ones. */
     anyOrigin(node: ts.Node): boolean;
+    /** badType's commit: the diagnostic carries the structured type
+     * failure (report-only in stage L0), and so does the poison. */
+    private typeFail;
+    /** Localized failure's commit point (design §3.3): `e` poisoned a unit
+     * whose failure is about to enter the build. When it is a degradable type
+     * failure at a slot kind in `slots`, the failing type joins
+     * degradedTypes (its lenient mapping is the checked dynamic, whole slot),
+     * the failure's own diagnostic leaves the build, and the caller lowers
+     * the unit again. Returns the slot to record once that retry succeeds,
+     * or null to commit as today. Never inside a capture buffer (a probe or a
+     * deferred collection) and never under --tier=static-only. */
+    degradeAtCommit(e: unknown, slots: ReadonlySet<TypeFailureSlot>): DynamicSlot | null;
+    /** A declaration slot whose type maps through degradedTypes is a
+     * dynamic slot too, though only the first such slot failed: record it
+     * (outside probes; the lookup is skipped while nothing is degraded). */
+    noteDegradedSlot(node: ts.Node, type: ts.Type): void;
+    /** Localized failure, statement commit point for declarations a probe
+     * flushed: a statement committing the flushed diagnostics of a deferred
+     * declaration (inside a capture buffer the flush could not retry) reopens
+     * it here, outside every probe. When the declaration's diagnostics are
+     * all retriable, they leave the build, the declaration retries
+     * (retryDeferred), and on success the caller lowers the statement again.
+     * Returns whether some declaration registered. */
+    reopenFlushedAtCommit(diagsBefore: number): boolean;
+    /** A failed attempt's own diagnostics leave the build before its unit
+     * lowers again; flushed declaration diagnostics (`rejects`) stay, since
+     * the retry will not flush them a second time. */
+    dropAttemptDiags(diagsBefore: number): void;
+    /** A unit that still fails after its retries commits its first
+     * attempt's own diagnostics (`first`, taken before the first
+     * degradation) in place of the last attempt's. The diagnostics the
+     * retries carry (dropAttemptDiags) stay as they are now: a declaration
+     * reopened since may have registered. */
+    restoreFirstAttemptDiags(diagsBefore: number, first: readonly ScrDiagnostic[]): void;
+    /** Lowers one unit whose body-level poison skips it (a generic
+     * instance), with localized failure's commit point: a degradable type
+     * failure at one of its declaration slots degrades the type and the unit
+     * lowers again (at most MAX_DECLARATION_RETRIES times). Null when it
+     * still poisons; its diagnostics are then committed as before. */
+    lowerUnitDegrading<T>(lower: () => T): T | null;
+    /** Localized failure's lenient mapping (stage L3, push-down): the type
+     * mapped with each failing component as the checked dynamic, so a record
+     * keeps its static members, an array of records its records, and a
+     * function its arity. The whole slot is the checked dynamic when even
+     * that shape does not map. Throwaway context: nothing memoizes. */
+    lenientType(type: ts.Type): IrType;
+    /** Degrades a type for a commit point: its lenient (pushed-down) form
+     * first; a type already degraded that still fails falls back to the
+     * whole-slot checked dynamic. False when nothing is left to degrade. */
+    private degradeType;
+    /** The IR type of a type's canonical form (canon-map.ts), or null when
+     * the form is irreducible, unbound, only the checked dynamic, or holds a
+     * union that mapped to the checked dynamic (such a slot is dynamic in
+     * part, so it degrades like any other). Runs only at localized failure's
+     * commit points, so a program that compiles today never consults it. */
+    canonicalType(type: ts.Type): IrType | null;
+    /** The degraded type of `id` maps exactly (canonical form): its slots
+     * are static, not dynamic. */
+    isCanonicalDegraded(id: number): boolean;
+    /** Some degraded type kept a pushed-down (partial) shape, or one was
+     * mapped before a retry widened it: the IR lowered before the retry keeps
+     * that shape. */
+    hasPartialDegradedTypes(): boolean;
+    /** Runs a unit a commit point may retry, recording the pushed-down
+     * types it maps; the frame's hits also count for the enclosing unit. */
+    withPartialHits<T>(hits: Set<number>, run: () => T): T;
+    /** Push-down is a refinement, never a new failure: a unit that still
+     * fails after mapping pushed-down types falls back to the whole-slot
+     * checked dynamic for them. True when some type widened (retry). */
+    widenPartials(hits: ReadonlySet<number>): boolean;
+    /** Records a dynamic slot whose unit lowered with it (one per site). */
+    noteDynamicSlot(slot: DynamicSlot): void;
+    /** The SC1090 refusal of checked-dynamic class fields in TypeScript
+     * (classFieldStoresDyn): a policy fence, not a missing representation.
+     * A flush retry lifts it (liftDynFieldPolicy), so a reached class with
+     * an 'any' field registers. */
+    dynFieldPolicyFence(node: ts.Node, feature: string): never;
     badType(node: ts.Node, type: ts.Type): never;
     /** The lib fence (SC2020): a reached use of standard-library surface
      * nothing lowers. Poisons the statement like every other rejection.
      * `sym`, when given, picks the wording: surface declared only by the
      * adopted @types/node is blamed at @types/node. */
     noLowering(surface: string, node: ts.Node, hint?: string, sym?: ts.Symbol | null, reason?: string): never;
+    /** The declaration-side refusal of a stdlib-global snapshot read as a
+     * VALUE (stdlibGlobalAliasDecl): report once, at the declaration's name,
+     * naming the type the program asked the compiler to hold when it has a
+     * short spelling. */
+    reportStdlibSnapshot(symbol: ts.Symbol): void;
     stdlibMemberFence(access: ts.PropertyAccessExpression): void;
     fenceStaticResponseMember(access: ts.PropertyAccessExpression | ts.ElementAccessExpression, use: "read" | "call"): IrExpr | null;
     fenceUnsupportedFetchConstructorMember(access: ts.PropertyAccessExpression | ts.ElementAccessExpression): IrExpr | null;
@@ -1873,6 +2313,20 @@ export declare class Lowerer {
      * over literal arguments). Inert outside generic function and class
      * instantiation. */
     readonly typeParamTsResolver: (t: ts.Type) => ts.Type | null;
+    /** The concrete instantiation of a generic alias reference (`Catalog<G,
+     * P>`) the current call-keyed instance's signature declares
+     * (boundAliasInstances), or null when its signature never instantiated
+     * that reference. Inert outside generic function instantiation. */
+    readonly boundAliasTsResolver: (t: ts.Type) => ts.Type | null;
+    private structuredCloneReadCounts;
+    /** How often the program reads `workerData` (every expression spelling it,
+     * counted conservatively) and registers a `"message"` listener: a
+     * structured clone read at one site only has no other holder
+     * (narrowing.ts freshDynSource). Computed once per lowering pass. */
+    structuredCloneReads(): {
+        workerData: number;
+        messageListeners: number;
+    };
     irTypeOf(node: ts.Node): IrType;
     /** Exact-shape enforcement (SC2002). Records are monomorphic structs, so
      * everywhere a value flows into a typed slot (call arg, initializer,
@@ -1916,7 +2370,11 @@ export declare class Lowerer {
     unionRecordWidthHelper(fromId: string, target: IrType & {
         kind: "record";
     }, loc: SrcLoc): string;
+    unionArrayWidthHelper(fromId: string, target: IrType & {
+        kind: "array";
+    }, loc: SrcLoc): string;
     recordWidthPlan(fromId: string, toId: string): Map<string, FieldLift> | null;
+    recordOvfCapturePlan(fromId: string, toId: string): RecordOvfCapturePlan | null;
     describeRecordWidthBlocker(fromId: string, toId: string): string | null;
     recordWidthHelper(fromId: string, toId: string, loc: SrcLoc): string | null;
     tupleArrayWidthHelper(fromId: string, toT: IrType & {
@@ -1992,8 +2450,11 @@ export declare class Lowerer {
      * wrap implicitly (coerceToExpected), then the exact-type fence runs
      * (SC2002 for record shapes, SC2003 for unions). Every slot-directed
      * lowering goes through here (via lowerExprExpecting) or calls this
-     * directly when the expression was already lowered. */
+     * directly when the expression was already lowered. In package files, a
+     * check this coercion creates names the package declaration that types
+     * the slot (decl-origin.ts). */
     coerceInto(node: ts.Node, expr: IrExpr, expected: IrType): IrExpr;
+    private coerceIntoSlot;
     /** The unit an 'any' expression PROVABLY holds on every run, or null
      * when no proof exists. The node must be an identifier whose every
      * declaration is a plain,
@@ -2162,6 +2623,12 @@ export declare class Lowerer {
      * may follow) — reached-but-broken declarations report the same set of
      * diagnostics the eager collector historically produced. */
     flushDeferred(symbol: ts.Symbol): void;
+    /** A statement's lowering used a declaration: if that declaration was
+     * rejected, the statement's own failure (if any) is its cascade. */
+    touchRejected(symbol: ts.Symbol): void;
+    /** Records a declaration whose deferred diagnostics reached the build:
+     * its failure group, on the group's diagnostics too. */
+    private noteRejected;
     /** flushDeferred without the collection-pass guard: for declarations
      * whose diagnostics must report eagerly (class statements with
      * declaration-time code, extended bases — collectClassShapeDeferring). */
@@ -2170,7 +2637,29 @@ export declare class Lowerer {
      * diagnostic is reported, so it leaves the declaration's deferred list
      * (the declaration counts as flushed for the coverage remainder). */
     private commitFlush;
-    flushDeferredClass(className: string): void;
+    /** Flushes a deferred class known by its IR name, and answers the class
+     * when the flush registered it (retryDeferred). */
+    flushDeferredClass(className: string): ClassInfo | undefined;
+    /** Localized failure's declaration commit point (design §3.3): a
+     * reference is flushing a deferred declaration into the build. When
+     * every deferred diagnostic is a degradable type failure at one of the
+     * declaration's slots, the failing types degrade and the collection
+     * runs again (up to MAX_DECLARATION_RETRIES rounds, each degrading the
+     * types the previous round still failed on). On success the
+     * declaration registers, each degraded slot is an SC6104, and nothing
+     * reports. Otherwise the last round's diagnostics stay deferred for the
+     * caller to commit. */
+    private retryDeferred;
+    private retryDeferredRounds;
+    private retryDegraded;
+    /** A deferred class with static field initializers is reached where its
+     * statement evaluates: Node runs the initializers there, referenced or
+     * not. Its file's %init calls this at that place, which retries the class
+     * as a flush would, so the initializers lower in place. A failed retry
+     * reports nothing and leaves the class deferred as it was, and from here
+     * on no flush registers it (staticInitsPassed): it reports instead.
+     * Returns whether the class has registered. */
+    retryDeferredAtDeclaration(symbol: ts.Symbol): boolean;
     collectSignature(decl: ts.FunctionDeclaration): void;
     collectSignatureInner(decl: ts.FunctionDeclaration): void;
     collectGenericSignature(decl: ts.FunctionDeclaration): void;
@@ -2203,6 +2692,11 @@ export declare class Lowerer {
         ordinal: number;
     }): void;
     lowerClassExpressionInfo(expr: ts.ClassLikeDeclaration): ClassInfo;
+    /** Batch-prefetches the symbols of every runtime identifier of the
+     * program's files. Collection's early-binding scan and the runtime-
+     * optional analysis look them up across every body, reached or not;
+     * one batch answers both, instead of one request per identifier. */
+    private prefetchProgramSymbols;
     /** Depth of the whole-program analyses that query types across every
      * file before reachability is known (speculativeTypeQueries). */
     private speculativeTypeQueryDepth;
@@ -2263,6 +2757,9 @@ export declare class Lowerer {
      * bodies as worklist units (the units map is otherwise built before
      * lowering starts). Null in the emit pass. */
     onExprClassCollected: ((info: ClassInfo) => void) | null;
+    /** emitReachable's unit registration for a declaration retryDeferred
+     * registered after collection. */
+    onDeclarationRegistered: ((decl: ts.Node) => void) | null;
     /** Mixin functions (`(Base: T) => class extends Base {…}`) by their
      * function-like node: recognized shape, or null for checked
      * non-qualifiers (lower-mixins.ts). */
@@ -2400,7 +2897,7 @@ export declare class Lowerer {
     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;
+    noteBlockedBindings(stmt: ts.Statement, diags?: readonly ScrDiagnostic[]): void;
     isBlockedBinding(symbol: ts.Symbol | null): boolean;
     /** The cascade rejection: an honest "inherits its declaration's blocker"
      * diagnostic (SC2004) when the symbol is a known-blocked binding, the
@@ -2606,6 +3103,13 @@ export declare class Lowerer {
         member: string;
     }, loc: SrcLoc): IrExpr | null;
     lowerNativeCallableValue(fn: BuiltinModuleFn, display: string, loc: SrcLoc): IrExpr | null;
+    /** The name and length a builtin function's adapter boxes under: the ones
+     * Node's function carries (`[Function: randomUUID]`). Empty for any other
+     * value. */
+    builtinFunctionIdentity(expr: IrExpr): {
+        fnName?: string;
+        fnLength?: number;
+    };
     isBuiltinCallableValue(expr: IrExpr): boolean;
     lowerBuiltinModuleCall(expr: ts.CallExpression, bi: {
         module: string;