@scriptc/compiler 0.0.0 → 0.0.2

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

@@ -0,0 +1,1748 @@
+import * as ts from "../ts7/adapter.js";
+import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
+import { UNSUPPORTED } from "../../diagnostics/diagnostic.js";
+import type { IrClassDef, IrExpr, IrFunction, IrGlobal, IrLocal, IrModule, IrParam, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/nodes.js";
+import { type DynamicImportResolution, type NpmBuiltinUse, type NpmLazyTrap } from "../npm.js";
+import { type StartupCrash } from "../program.js";
+import { ShapeRegistry, type TypeMapperCtx, UnionRegistry } from "../types.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 { FieldTarget } from "./lower-exprs.js";
+import type { ExpandoMember } 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: "objWidth";
+} | {
+    how: "clsWidth";
+};
+export declare class PoisonError extends Error {
+}
+/** Own-property lookup for the surface tables. They are plain object
+ * literals, so a bare `table[name]` would also find Object.prototype
+ * members ("toLocaleString", "constructor", "valueOf") — genuine member
+ * 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;
+/** Sentinel binding key for `this` (which has no ts.Symbol): a stable
+ * object identity used in the same scope/capture maps as real symbols, so
+ * arrows capturing `this` ride the ordinary capture machinery. */
+export declare const THIS_BINDING: ts.Symbol;
+/** 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;
+    } | null;
+    /** VARIADIC `arguments` form (rest-marked func type with no declared
+     * rest param): the synthetic trailing DOM-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 control constructs, innermost last: loops/switches/labeled
+     * blocks (jump targets — `labels` carries their JS label names so labeled
+     * break/continue resolve), try-with-finally regions ("tryFinally" — a
+     * try/catch body guarded by a finally: `return` crosses them now via the
+     * backend's pending-return path; break/continue still reject), and
+     * finally BLOCKS themselves ("finallyBlock" — jumps out stay rejected: a
+     * return there would REPLACE a pending completion, a model the emitter
+     * doesn't implement; see rejectJumpCrossingFinally). Per function: a
+     * nested function's jumps never bind to enclosing constructs. */
+    ctl: {
+        kind: "loop" | "switch" | "block" | "tryFinally" | "finallyBlock";
+        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). */
+    statementsTotal: number;
+    statementsFailed: number;
+    /** Statements that LOWERED but contain island constructs (jsOp/jsExit —
+     * package calls, island-backed lib members): they compile, but their
+     * work runs in the embedded engine. Only a --dynamic analysis produces
+     * these; coverage renders them as "compile dynamically". */
+    statementsIsland: number;
+    /** Functions whose signature couldn't be analyzed (bodies not counted). */
+    functionsSkipped: number;
+}
+/** IrStmt discriminants — the island walk below must not descend into
+ * NESTED statements (each is counted individually by its own lowerStmts
+ * visit; descending would attribute a nested island statement to every
+ * enclosing construct too). The top-level statement object itself is
+ * always visited. */
+export declare const IR_STMT_KINDS: Set<string>;
+/** 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[];
+export declare function stmtUsesIsland(stmts: IrStmt | IrStmt[]): boolean;
+export interface LowerResult {
+    /** Present iff diagnostics is empty. */
+    module: IrModule | null;
+    diagnostics: ScrDiagnostic[];
+    /** JS statements whose compile fences DEFERRED to runtime (runtimeFence
+     * statements in the module) — off the build, on the coverage report. */
+    runtimeFences: ScrDiagnostic[];
+    stats: LowerStats;
+    /** --provenance-sources only: per-file statement attribution (the
+     * coverage report aggregates it per provenance package). */
+    statsByFile?: Map<string, {
+        total: number;
+        failed: number;
+        island: number;
+    }>;
+    /** --provenance-sources only: diagnostics of elided pure-annotated dead
+     * consts in fetched source modules — off the build, on the report. */
+    provenanceElided?: ScrDiagnostic[];
+    /** Coverage only (LowerOptions.coverage): the unreached remainder,
+     * lowered in a throwaway pass — blockers in it can never fail a build. */
+    unreached?: {
+        diagnostics: ScrDiagnostic[];
+        stats: LowerStats;
+    };
+    /** --dynamic only: every Node builtin the embedded npm graph imports,
+     * shimmed or not — the coverage report's island honesty. */
+    npmBuiltins?: NpmBuiltinUse[];
+    /** --dynamic only: unresolvable specifiers reached ONLY by require()/
+     * import() edges — the build embeds Node's call-time error as a runtime
+     * trap; the coverage report lists them beside the builtins. */
+    npmLazyTraps?: NpmLazyTrap[];
+}
+export interface LowerOptions {
+    /** --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. */
+    dynamic?: boolean;
+    /** Coverage: additionally lower the unreached remainder (bodies nothing
+     * on the entry path reaches) in a throwaway pass and report its
+     * diagnostics and stats under `unreached` — the whole-program analysis
+     * builds deliberately gave up. */
+    coverage?: boolean;
+    /** The platform the build TARGETS ("win32" under a windows cross triple,
+     * the host platform otherwise — see buildTargetPlatform in index.ts).
+     * The whole program compiles for one platform, so the platform-keyed
+     * surfaces are compile-time constants: on win32 the bare path module
+     * binds path.win32 (Node on Windows IS path.win32) and path.sep /
+     * path.delimiter / os.EOL lower as the win32 literals; path.posix and
+     * path.win32 keep answering THEIR platform everywhere, like Node's. */
+    targetPlatform?: string;
+    /** Node's startup refusal (LoadResult.startupCrash — preflight's
+     * resolution walk and CJS named-import link check): the program
+     * compiles to that startup crash. */
+    startupCrash?: StartupCrash | null;
+}
+/** The Lowerer's pass configuration (see lowerToIr). */
+export interface LowererMode {
+    /** Names of bodies the discovery pass reached; null lowers everything. */
+    reachable?: ReadonlySet<string> | null;
+    /** Coverage remainder: lower ONLY bodies outside `reachable`, skip the
+     * always-reachable init bodies and module building, and report deferred
+     * collection diagnostics nothing flushed. */
+    remainder?: boolean;
+    /** Symbols whose deferred diagnostics the emit pass already flushed —
+     * the remainder must not report them a second time. */
+    alreadyFlushed?: ReadonlySet<ts.Symbol>;
+    /** The build's target platform (LowerOptions.targetPlatform — lowerToIr
+     * passes it to every pass). Defaults to the host. */
+    targetPlatform?: string;
+    /** Node's startup refusal (preflight's resolution walk / CJS named-
+     * import link check): %main opens with exactly this throw, before any
+     * module init — Node refuses the whole graph before anything evaluates,
+     * so nothing runs. */
+    startupCrash?: StartupCrash | null;
+}
+/** Build lowering runs in two passes over the same ts.Program:
+ *
+ * 1. DISCOVERY — a worklist computes the set of reachable bodies. Seeds are
+ *    the per-file init bodies (module top-level statements always run, in
+ *    import order); lowering a body yields IR whose call/closure/new/
+ *    virtualCall nodes are the edges that enqueue further bodies. The
+ *    pass's IR, diagnostics, and stats are discarded — it exists only to
+ *    answer "which bodies does the entry reach?".
+ * 2. EMIT — a fresh Lowerer lowers in the HISTORICAL order (per file:
+ *    function declarations, then class members; then file inits, %main,
+ *    generic instances, lifted lambdas), skipping bodies the discovery
+ *    pass did not mark. Keeping the emit order (and lambda/instance
+ *    numbering) identical to the pre-reachability compiler means a fully
+ *    reachable program emits byte-identical C.
+ *
+ * `coverage: true` adds a third pass — the REMAINDER — that lowers only
+ * the bodies discovery did NOT mark (plus deferred collection diagnostics
+ * nothing flushed), reported separately: whole-program analysis without
+ * letting unreached code fail builds. */
+export declare function lowerToIr(program: ts.Program, entry: ts.SourceFile, moduleOrder: ts.SourceFile[], options?: LowerOptions): LowerResult;
+/** The island-handle type a `import(...)` initializer gives a binding
+ * whose DECLARED type has no static mapping (`Promise<typeof
+ * import("./m")>` — module-namespace types don't map): the direct form
+ * holds the static promise-of-handle, the awaited form holds the handle
+ * itself. Null for every other initializer shape. */
+export declare function importCallHandleType(expr: ts.Expression | undefined): IrType | null;
+/** True when `expr` is a call that resolved to an overload SIGNATURE of a
+ * source-implemented function whose implementation returns an island value
+ * (`any` under --dynamic): tsc never checks overload return types against
+ * the body — only the implementation signature is checked — so the
+ * overload's return is an unverifiable claim about an island value. The
+ * binding stores the HANDLE instead of trap-extracting the claimed type
+ * (reconcileOverloadReturn keeps the call jsval by the same rule), and
+ * uses dispatch to engine ops — exactly the value Node's binding holds.
+ * Ambient (.d.ts) declarations never reach this: they have no compiled
+ * implementation, so their calls lower through the island/builtin paths
+ * whose validated exits keep the checker-trust trap. */
+export declare function uncheckedOverloadHandleCall(L: Lowerer, expr: ts.Expression | undefined): boolean;
+/** The JavaScript declaration fallback for unmappable binding types (see
+ * irTypeOf): `any` and every other inference residue is the checked-
+ * dynamic 'unknown' kind, and array types keep their array-ness with the
+ * fallback applied to the ELEMENT (any[]/never[] evolving arrays become
+ * unknown[], so length/push/index still lower). Null for TypeScript
+ * files and for void (no value exists to represent). */
+/** A JS-file type carrying `never[]` (or a never element) ANYWHERE in its
+ * array/tuple/union structure: tsc's inference residue for evolving and
+ * information-free shapes — the bare `const gb = []` (never[]), the mixed
+ * command tuple `['pwd', []]` ((string | never[])[]). never's f64
+ * representation (mapType's uninhabited stance, sound for genuinely dead
+ * TS reads) must not capture these VALUES — a later dyn push would
+ * dynCheck strings into a number array, a union arm would re-tag as
+ * number[] and fence. Callers treat a tainted type as unmappable so the
+ * checked-dynamic fallbacks apply, the pre-never-mapping behavior. Bare
+ * `never` at the ROOT stays out (`for (const v of [])`'s loop var — the
+ * dead read the f64 mapping is FOR). */
+export declare function neverTaintedJsType(L: Lowerer, node: ts.Node, t: ts.Type): boolean;
+/** The DOM undefined value — what an uninitialized checked-dynamic
+ * binding holds (JS: declared bindings read `undefined` before any
+ * assignment). A NULL dyn slot is a trap, never a value, so every dyn
+ * binding that is READABLE before its first assignment must start here:
+ * `let x;` declarations, hoisted `var`s (function and module scope,
+ * forward captures included), and the implicit-return completion
+ * (lower-calls' own copy of this pattern predates the helper). */
+export declare function dynUndefinedExpr(loc: SrcLoc): IrExpr;
+/** The checked-dynamic declaration fallback for unmappable binding types
+ * (see irTypeOf), two gates over one story:
+ *
+ * JAVASCRIPT files: `any` and every other inference residue is the
+ * checked-dynamic 'unknown' kind, and array types keep their array-ness
+ * with the fallback applied to the ELEMENT (any[]/never[] evolving arrays
+ * become unknown[], so length/push/index still lower).
+ *
+ * TYPESCRIPT files: genuine checker-`any` residue ONLY — a bare `any`
+ * binding (`flags & Any`), or a single-call-signature function type whose
+ * only unmappable pieces are `any` (`(value: any) => value is string` —
+ * the arrow the binding holds lowers those params to dyn, so the binding
+ * keeps its func-ness with the same per-piece fallback). The honest
+ * static subset of `any` is a binding whose VALUES are DOM-representable:
+ * the binding is 'unknown' storage with the boundary conversions
+ * coerceToExpected already applies (dynFrom into the slot, validated
+ * dynCheck out) and per-site SC2011 fences for the operations the DOM
+ * cannot carry JS-exactly (the island still lifts those). Every OTHER
+ * unmappable TS type keeps its own diagnostic — annotations exist there,
+ * and the fence names the real blocker. `--dynamic` builds never reach
+ * this fallback for `any` (mapType answers jsval first).
+ *
+ * Null for void (no value exists to represent). */
+export declare function dynFallbackType(L: Lowerer, node: ts.Node, t: ts.Type): IrType | null;
+/** The best-effort JS `Function.prototype.name` of an expression flowing
+ * into a dyn slot (the boxed function kind's inspect/error name):
+ * identifier and property reads answer the referenced NAME (a
+ * REFERENCE-SITE approximation of JS's creation-site naming — an aliased
+ * binding reports the alias; SEMANTICS.md), named function expressions
+ * 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). */
+export declare function jsFuncNameOf(node: ts.Node): string | null;
+export declare class Lowerer {
+    readonly program: ts.Program;
+    readonly entry: ts.SourceFile;
+    readonly moduleOrder: ts.SourceFile[];
+    readonly dynamic: boolean;
+    readonly checker: ts.TypeChecker;
+    readonly diags: ScrDiagnostic[];
+    readonly fnSigsBySymbol: Map<ts.Symbol, FnSig>;
+    readonly genericFnsBySymbol: Map<ts.Symbol, GenericFnInfo>;
+    /** 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>;
+    /** 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>;
+    /** Per-symbol result of the never-reassigned file scan
+     * (bindingNeverReassigned — object-literal generic-method receivers). */
+    readonly neverReassignedCache: Map<ts.Symbol, boolean>;
+    /** 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>;
+    /** Monomorphization worklist: instances queued by call sites, drained in
+     * run() (processing an instance body can queue more). */
+    readonly instantiationQueue: {
+        info: GenericFnInfo;
+        inst: GenericInstance;
+    }[];
+    /** Non-null while an instance body lowers: type-parameter symbol →
+     * concrete IR type, consulted inside mapType's recursion. */
+    typeParamBindings: Map<ts.Symbol, IrType> | null;
+    /** Non-null while an IMPLICIT-ANY instance body lowers (npm-static JS —
+     * lower-calls' implicit-monomorphization section): bound param symbol →
+     * the call site's checker type, consulted by typeOf for identifier
+     * references the checker still types `any`. The implicit twin of
+     * typeParamBindings — the checker has no `T` to substitute, so the
+     * binding rides the node-type accessor instead of mapType. */
+    implicitParamTypes: Map<ts.Symbol, ts.Type> | null;
+    /** IMPLICIT-ANY instances lowered EAGERLY at first demand (their return
+     * types are inferred from the body — the call site needs them settled),
+     * collected here for run()'s function list (the liftedFns discipline). */
+    readonly implicitFns: IrFunction[];
+    /** ALIASED-TYPEOF narrowing (npm-static JS — ms's `var type = typeof
+     * val; if (type === 'string') ...`): while a branch such a test proves
+     * lowers, the tested operand's symbol maps to the proven ARM's checker
+     * type here, and typeOf answers it — the checker only narrows const
+     * aliases, so this carries the var/let form the checker cannot.
+     * Scoped strictly by narrowingAliases (lowerIf / lowerCondition). */
+    readonly aliasNarrowTypes: Map<ts.Symbol, ts.Type>;
+    /** Runs `fn` with the given aliased-typeof narrows applied (and restored
+     * after) — the branch-scoping primitive. */
+    narrowingAliases<T>(narrows: readonly {
+        sym: ts.Symbol;
+        tsArm: ts.Type;
+    }[], fn: () => T): T;
+    /** Non-null while an instance body lowers: appended to every diagnostic
+     * so a body error names WHICH instantiation triggered it. */
+    instantiationContext: string | null;
+    /** True while re-lowering a base function's 2nd+ instance: the same source
+     * statements were already counted for the first instance. */
+    suppressStats: boolean;
+    /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
+     * interned per method + element/callback-result type: key → fn name. */
+    readonly arrHofHelpers: Map<string, string>;
+    /** Width-coercion helpers (%rec.width.N / %arr.width.N), interned per
+     * (from, to) shape pair — see widthCoerce. */
+    readonly widthHelpers: Map<string, string>;
+    /** (fromShape, toShape) pairs whose width plan is being computed — the
+     * cycle guard for RECURSIVE shapes (a self-referential record narrowing
+     * into a self-referential subset). Re-entering an in-progress pair
+     * answers "assume coercible" (the greatest fixed point: every OTHER
+     * constraint of the cycle is still checked by the outer call, and the
+     * built helper terminates because recordWidthHelper interns its name
+     * before building the body, so the recursive reference resolves to the
+     * helper itself). */
+    private readonly widthPlanning;
+    /** Interned node:assert helpers (deep-equality comparisons keyed by
+     * typeKey, throws wrappers keyed by callback type + expected class) —
+     * the widthHelpers pattern with its own namespace. */
+    readonly assertHelpers: Map<string, string>;
+    /** util.inspect's per-type traversal helpers (%util.insp.N), interned
+     * by typeKey — the assertHelpers pattern with its own namespace. */
+    readonly inspectHelpers: Map<string, string>;
+    /** Union re-tag helpers (%union.retag.N), interned per (from, to)
+     * unionId pair — see unionRetagHelper. */
+    readonly retagHelpers: Map<string, string>;
+    /** Symbols bound by `const x = promisify(execFile)` — the one lowered
+     * util.promisify shape. Declarations register here and emit nothing;
+     * calls through the binding lower (lowerExecFileAsyncCall) and value
+     * uses fence. */
+    readonly promisifiedExecFile: Set<ts.Symbol>;
+    /** Symbols bound by `const process = globalThis.process` (and the other
+     * stdlib-global snapshot spellings): pure alias plumbing — receiver
+     * checks resolve through this map (stdlibGlobalNameOf), declarations
+     * emit nothing. */
+    readonly stdlibGlobalAliases: Map<ts.Symbol, string>;
+    /** 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, {
+        fnName: string;
+        type: IrType & {
+            kind: "func";
+        };
+    }>;
+    readonly narrowHelpers: Map<string, string>;
+    /** Interned `%iter.drain.<n>` helpers (classIteratorDrainCall): one per
+     * receiver class — the eager drain of a class iterable's protocol into
+     * a fresh element array, behind array/call spreads. */
+    readonly iterDrainHelpers: Map<string, string>;
+    /** Island-lift builder helpers (%jsin.rec.N / %jsin.arr.N /
+     * %jsin.elems.N), interned per source type — see jsvalLiftExpr. */
+    readonly jsinHelpers: Map<string, string>;
+    /** Synthetic Map.forEach loop functions, interned per key/value type +
+     * callback arity: key → fn name (see lowerMapForEachCall). */
+    readonly mapHofHelpers: Map<string, string>;
+    /** Synthetic Set.forEach loop functions, interned per element type +
+     * callback arity/return — Map's pattern. */
+    readonly setHofHelpers: Map<string, string>;
+    /** Synthetic URLSearchParams.forEach loop functions, interned per
+     * callback arity/return — Map's pattern over the sp index walk. */
+    readonly spHofHelpers: Map<string, string>;
+    /** Optional-chain lowering state. While a chain body lowers, the guarded
+     * receiver NODE reads as a chainRecv (typed by the narrowed arm) instead
+     * 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>;
+    /** 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
+     * the loop body lowers; the property path serves `m.index` as
+     * idxs[cur] — computed only at an actual read, so a drain row is never
+     * touched for bodies that ignore it). */
+    readonly matchAllIndexBindings: Map<ts.Symbol, {
+        idxsLocalId: string;
+        curLocalId: string;
+    }>;
+    /** STORED matchAll drains: `const rows = s.matchAll(re)` lowers through
+     * matchAllInto with a hidden companion index array, registered here so a
+     * later `for (const m of rows)` in the SAME function serves `m.index`
+     * (the ctx guard keeps hidden locals out of closures — a cross-function
+     * walk falls back to the plain array walk and the fence). */
+    readonly matchAllDrainIndexes: Map<ts.Symbol, {
+        idxsLocalId: string;
+        ctx: FnCtx;
+    }>;
+    chainCounter: number;
+    /** Keyed by program-wide qualified class name (what IR object types carry). */
+    readonly classes: Map<string, ClassInfo>;
+    readonly classBySymbol: Map<ts.Symbol, ClassInfo>;
+    /** 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;
+    readonly globalsBySymbol: Map<ts.Symbol, IrGlobal>;
+    /** Expando function members (`foo.bar = 12` on a module-level function
+     * 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>>;
+    /** 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 globalsList: IrGlobal[];
+    /** npm-import init statements (--dynamic), keyed by file AND import
+     * declaration: the island.import assignments/side-effect loads for that
+     * statement. lowerFileInit splices them into the importing file's %init
+     * header at the statement's position — Node evaluates each imported
+     * module (island packages included) where the import appears, so an
+     * `import "polyfill"` before an `import "./app.js"` runs the package
+     * top-level BEFORE app's init, not after. */
+    readonly npmInitActions: Map<ts.SourceFile, Map<ts.StatementBase, IrStmt[]>>;
+    /** Per-file %init PRELUDE statements for JSON imports: bakeable DATA
+     * assignments with no observable evaluation order of their own —
+     * prepended by lowerFileInit so the bindings are live before any
+     * top-level statement runs. */
+    readonly jsonInitActions: Map<ts.SourceFile, IrStmt[]>;
+    /** The embedded npm runtime graph (collectNpmImports), attached to the
+     * emitted module. Null without npm imports or without --dynamic. */
+    npmEmbedded: IrModule["embedded"] | null;
+    npmBuiltins: NpmBuiltinUse[] | null;
+    npmLazyTraps: NpmLazyTrap[] | null;
+    /** Dynamic `import("literal")` resolutions, keyed
+     * `fileName\u0000specifier` (collectDynamicImports fills it during npm
+     * collection; lowerDynamicImportCall reads it per site). */
+    readonly dynImports: Map<string, DynamicImportResolution>;
+    /** Module → the name of its synthesized namespace-BUILDER function
+     * (lowerOwnModuleImport): every `import()` of the same program module
+     * shares one builder. */
+    readonly dynNsBuilders: Map<ts.SourceFile, string>;
+    /** Parameters forced to the island-handle type (jsval) regardless of
+     * their checker type: then-handler params whose settled value is an
+     * engine handle (a dynamic import's namespace object) — paramShape's
+     * early-out. */
+    readonly jsvalParamOverrides: Set<ts.ParameterDeclaration>;
+    /** File → qualifier prefix: "" for the entry, "%mI." otherwise. */
+    readonly fileTag: Map<ts.SourceFile, string>;
+    /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
+     * "flattened" — an instantiated namespace whose body joined the file's
+     * parts (members resolve statically); "typeOnly" — a skipped
+     * 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, "typeOnly" | "flattened">;
+    /** File → its %init function name, filled by prepareModuleInits before
+     * any body lowers: import headers and inline require statements call
+     * dependency inits by these names. */
+    readonly initNameOf: Map<ts.SourceFile, string>;
+    /** File → the id of its run-once guard global (a bool module global,
+     * false at program start). Every non-entry module gets one: its %init
+     * may be called from several importers/requirers, and the guard is what
+     * makes each call after the first a Node-style cache hit. The entry has
+     * none — %main calls it exactly once (a dependency edge back to the
+     * entry would be a fenced cycle). */
+    readonly moduleGuardOf: Map<ts.SourceFile, string>;
+    /** Record-shape interner: canonical (name-sorted) field list → shapeId.
+     * Threaded into every mapType call; its `shapes` array becomes
+     * IrModule.records. */
+    readonly shapes: ShapeRegistry;
+    /** Union interner: canonical (typeKey-sorted) arm list → unionId.
+     * Threaded into every mapType call; its `unions` array becomes
+     * IrModule.unions. An arm's index in the canonical list is its runtime
+     * tag. */
+    readonly unions: UnionRegistry;
+    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). */
+    readonly typeCtx: TypeMapperCtx;
+    readonly stats: LowerStats;
+    /** Discovery-pass edge sink (null in the emit pass): every resolution of
+     * a reference to a lowerable body reports its name here — recorded even
+     * when the enclosing statement later poisons. */
+    onEdge: ((name: string) => void) | null;
+    fnStack: FnCtx[];
+    readonly liftedFns: IrFunction[];
+    lambdaCounter: number;
+    /** Statement lists currently mid-lowering, innermost last: the forward-
+     * capture machinery (predeclareForwardCapture) needs to know which later
+     * statements of an OPEN list a symbol's declaration sits in, which scope
+     * frame list-level declarations register into, and where to insert the
+     * scope-entry TDZ varDecl (before the statement being lowered). */
+    readonly activeStmtLists: {
+        stmts: readonly ts.Statement[];
+        index: number;
+        ctx: FnCtx;
+        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
+     * function called above the declaration statement reads that, never a
+     * NULL slot. Filled by collectGlobals. */
+    readonly varGlobalEntryInits: Map<ts.SourceFile, IrGlobal[]>;
+    get ctx(): FnCtx;
+    get scopes(): Map<ts.Symbol, IrLocal>[];
+    /** Names of bodies the discovery pass reached; null lowers everything
+     * (the discovery pass itself). */
+    readonly reachable: ReadonlySet<string> | null;
+    /** Coverage remainder mode: the reachability gate inverts (see wantBody)
+     * and no module is built. */
+    readonly remainder: boolean;
+    /** Deferred collection diagnostics (failed signatures/class shapes) by
+     * declaration symbol: an unreached declaration must not fail the build,
+     * so its diagnostics wait until a reference makes them relevant. */
+    readonly deferredDiags: Map<ts.Symbol, ScrDiagnostic[]>;
+    /** Deferred classes by qualified IR name — for flush sites that only
+     * know the class name (typed receivers, module class retention). */
+    readonly deferredClassByName: Map<string, ts.Symbol>;
+    /** Symbols whose deferred diagnostics THIS pass flushed (handed to the
+     * coverage remainder as alreadyFlushed). */
+    readonly flushedSymbols: Set<ts.Symbol>;
+    readonly alreadyFlushed: ReadonlySet<ts.Symbol>;
+    /** The build's target platform ("win32" | "darwin" | "linux" | ...):
+     * selects the platform-keyed builtin surfaces (builtinModuleFnsOf /
+     * builtinModuleConstOf in surfaces.ts). */
+    readonly targetPlatform: string;
+    /** LowererMode.startupCrash — buildMain opens %main with the throw. */
+    readonly startupCrash: StartupCrash | null;
+    /** Symbols a POISONED declaration statement would have bound: the
+     * declaration's own diagnostic is already recorded, and no local/global
+     * registered, so later references fall through every resolution step —
+     * the fallthroughs report the inherited-blocker cascade (SC2004)
+     * instead of misattributing the reference. */
+    readonly blockedBindings: Set<ts.Symbol>;
+    /** 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). */
+    collecting: boolean;
+    /** Non-null redirects pushDiag into a capture buffer (the deferred
+     * collection wrapper). */
+    diagSink: ScrDiagnostic[] | null;
+    /** Diagnostics converted into runtimeFence statements (JS sources —
+     * see lowerStmts): off the build, preserved here so coverage reporting
+     * can still name every deferred fence. */
+    readonly runtimeFences: ScrDiagnostic[];
+    /** --provenance-sources: diagnostics of ELIDED pure-annotated dead
+     * consts in fetched source modules (lowerStmts's elision rule) — off
+     * the build entirely (the statement lowers to its poisoned bindings and
+     * nothing throws), preserved for the coverage report's provenance
+     * section. */
+    readonly provenanceElided: ScrDiagnostic[];
+    /** --provenance-sources: per-file statement attribution (mirrors the
+     * stats counters, keyed by fileName) so the coverage report can answer
+     * "did the PACKAGE's statements compile static?" per provenance
+     * package. Only populated while the registry is active; the remainder
+     * pass skips it (attribution describes the build). */
+    readonly statsByFile: Map<string, {
+        total: number;
+        failed: number;
+        island: number;
+    }>;
+    /** 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" | "island"): void;
+    constructor(program: ts.Program, entry: ts.SourceFile, moduleOrder: ts.SourceFile[], dynamic: boolean, mode?: LowererMode);
+    registerBuiltinErrorClasses(): void;
+    builtinErrorInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
+    builtinEmitterInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
+    builtinStreamInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
+    /** Program-wide qualified name for a top-level declaration. */
+    qualify(sf: ts.SourceFile, name: string): string;
+    /** The IR name mapType gives class instance types — must agree with
+     * collectClassShape's registration. Namespace-nested classes carry the
+     * namespace path (nsPathPrefix), so `namespace A { export class C }`
+     * and a top-level `class C` never collide. Class EXPRESSIONS name by
+     * SOURCE POSITION (`%cx<start>.<name>`): deterministic across the
+     * discovery and emit passes (no counter can drift between them),
+     * program-unique through the file qualifier, and collision-free with
+     * user identifiers ('%'). */
+    readonly classNamer: (decl: ts.ClassLikeDeclaration) => string;
+    /** Follows import aliases to the original declaration's symbol. Every
+     * value reference resolves through here, so it doubles as the flush
+     * point for deferred collection diagnostics: resolving a reference to a
+     * broken declaration reports what collection deferred. */
+    resolveValueSymbol(ident: ts.Identifier): ts.Symbol | null;
+    /** A module's CJS export-table member symbol by NAME (the checker's
+     * module-symbol exports map — present in tsgo even where no expando
+     * property symbol exists at the attachment/use sites). */
+    cjsModuleExportSymbol(sf: ts.SourceFile, name: string): ts.Symbol | undefined;
+    /** The local VALUE symbol behind a CJS export-table property symbol —
+     * see resolveValueSymbol. Null when `symbol` is not such a property (or
+     * the property's value is not a plain identifier reference). */
+    private cjsExportValueSymbol;
+    /** The CLASS symbol a member-form CJS export declaration forwards to:
+     * `d` (an export property symbol's declaration) sits in a top-level
+     * `exports.C = <ident>` / `module.exports.C = <ident>` statement of a
+     * JS module, the statement is not discarded by a later table, and the
+     * identifier resolves to a class declaration. Null otherwise. */
+    cjsMemberExportClassSymbol(d: ts.Node): ts.Symbol | null;
+    /** The CommonJS JS module a DEFAULT-import binding's declaration loads
+     * (`import d from "./lib.cjs"`), or null: Node's ESM-CJS interop binds
+     * the default to module.exports — exactly a require binding — so those
+     * bindings ride the CJS namespace machinery below. ESM dependencies
+     * (any .ts, ESM-syntax .js/.mjs) answer null and keep the ESM default
+     * machinery. */
+    private cjsDefaultImportDepOf;
+    /** True when `expr` is an identifier bound by a top-level
+     * `const x = require("./local")` of a RELATIVE module — the CommonJS
+     * namespace binding — or by a DEFAULT import of a CommonJS JS module
+     * (`import d from "./lib.cjs"`: Node binds d to module.exports, the
+     * same value require answers). Member accesses on it resolve through
+     * the export table (property symbols → resolveValueSymbol); the bare
+     * value keeps the namespace-object fence, like ESM namespace imports
+     * of builtins. */
+    cjsLocalModuleBindingOf(expr: ts.Expression): boolean;
+    /** Assignment-target resolution: a function local (possibly captured) or
+     * a module global. tsc has already rejected writes to consts. */
+    resolveWritable(ident: ts.Identifier): {
+        id: string;
+        type: IrType;
+    } | null;
+    fnSigOf(ident: ts.Identifier): FnSig | null;
+    globalOf(ident: ts.Identifier): IrGlobal | null;
+    splitFiles(): FileParts[];
+    collectProgram(parts: FileParts[]): void;
+    /** Names every file's %init and registers the run-once guard globals
+     * (EVERY module, the entry included: an admissible import cycle can
+     * close back on the entry, whose init call must be the cache hit Node's
+     * revisit is — not a recursion) BEFORE any body lowers: function bodies
+     * and init bodies alike may contain require statements that lower to
+     * calls of these names. Runs in every pass so the ids are
+     * deterministic. */
+    prepareModuleInits(parts: FileParts[]): void;
+    /** The lowering of a CommonJS `require("./local")` occurrence: a call of
+     * the required module's run-once %init at exactly this statement's
+     * position — Node's inline evaluation, with the guard supplying the
+     * cache-hit behavior for every require after the first. Null when the
+     * specifier is not a relative program module (builtins load nothing;
+     * anything else kept its preflight fence). */
+    requireInitStmt(spec: string, node: ts.Node): IrStmt | null;
+    /** True when this body should lower: everything with no reachable set
+     * (discovery), the marked bodies in the emit pass, and exactly the
+     * UNMARKED bodies in the coverage remainder. */
+    wantBody(name: string): boolean;
+    collectNpmImports(parts: FileParts[]): void;
+    collectJsonImports(parts: FileParts[]): void;
+    run(): LowerResult;
+    /** 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
+     * (interned ids can nest). */
+    typeNamesUnregisteredClass(t: IrType, seen?: Set<string>): boolean;
+    /** Whether run() counts a signature-blocked declaration in
+     * stats.functionsSkipped: whole-program passes and the coverage
+     * remainder do; the reachability emit pass leaves the counting to the
+     * remainder (the declaration was never reached). */
+    countsSkips(): boolean;
+    /** The discovery pass: computes the set of body names the program's entry
+     * reaches. Seeds are the per-file init bodies (top-level statements always
+     * run); edges fire from RESOLUTION sites while a body lowers (noteEdge /
+     * noteVirtualEdge) — direct calls, closure creation (a taken closure may
+     * be called indirectly), `new`, super calls, accessor invocations, and
+     * virtual dispatch. Recording at resolution time (not off the produced
+     * IR) keeps edges from statements that later poison, so the callee's own
+     * diagnostics still surface — the collect-everything invariant. Generic
+     * instances ride the existing monomorphization queue (already
+     * demand-driven) and lifted lambdas lower inline with their enclosing
+     * body; both fire edges through the same hooks and are not units
+     * themselves. */
+    discover(): Set<string>;
+    /** Discovery hook (see discover): fires when lowering resolves a
+     * reference to a lowerable body. Inert in the emit pass. */
+    noteEdge(name: string): void;
+    /** Discovery hook for virtual dispatch: a virtualCall on `info`'s static
+     * class reaches the nearest declaration at/above it plus every override
+     * on a STRICT descendant (receivers of sibling branches can't flow into
+     * this call site; a virtualCall through their own static classes marks
+     * them). */
+    noteVirtualEdge(info: ClassInfo, method: string): void;
+    moduleArtifacts(functions: IrFunction[]): {
+        classes: IrClassDef[];
+        records: IrRecordShape[];
+        unions: IrUnionDef[];
+    };
+    /** All diagnostics land here; while a generic instance body is lowering,
+     * 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): never;
+    /** The dynamic-family fence for an OPERATION on an `any`-origin
+     * checked-dynamic value that only the engine can execute (operators,
+     * iteration, computed member names, ...). Carries SC2011 — the same
+     * code as the `any` type fence — so the coverage report groups it with
+     * the dynamic-capable family and the two-tier retry knows the island
+     * lifts the site. Use exactly when the blocking operand IS dyn-typed
+     * and its checker type is `any`-flavored; genuine `unknown` keeps the
+     * SC1100-family fences (tsc constrains what unknown can do, so those
+     * sites are checker-error territory, not engine territory). */
+    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
+     * (the engine could run the operation) from genuine `unknown` ones. */
+    anyOrigin(node: ts.Node): boolean;
+    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): never;
+    stdlibMemberFence(access: ts.PropertyAccessExpression): void;
+    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;
+    /** True when a ?. token blocks this lowering — i.e. it is NOT the one an
+     * active optional-chain lowering is currently handling. Every receiver-
+     * typed lowering that supports chained receivers guards with this
+     * instead of a raw questionDotToken check. */
+    chainBlocked(...nodes: (ts.CallExpression | ts.PropertyAccessExpression | ts.ElementAccessExpression)[]): boolean;
+    /** formatIrType with this Lowerer's registries (records and unions expand
+     * to their structure in diagnostics). */
+    fmt(t: IrType): string;
+    /** isJsonSafeType with this Lowerer's registries — the shared fence for
+     * what JSON.stringify accepts and what a checked cast can validate. */
+    jsonSafe(t: IrType): boolean;
+    /** True when a type is a BARE undefined-armed union — the one JSON-unsafe
+     * shape whose rejections deserve their own wording: Node's stringify of
+     * bare undefined is not a string at all and JSON text never matches the
+     * arm, so exactness is unreachable and the fixes (narrow first / null arm
+     * / make it an optional record FIELD, where drop-and-absent semantics ARE
+     * Node's) are specific. Record fields don't count: an undefined-armed
+     * union in field position is JSON-safe (isJsonSafeType), so a record that
+     * still fails the fence does so for some other reason. */
+    bareUndefinedArmedUnion(t: IrType): boolean;
+    /** canCrossIslandBoundary with this Lowerer's registries — THE test
+     * behind every marshal/exit decision (the implicit coercions, jsvalIn,
+     * the checked island-exit cast). Rejections that follow a false answer
+     * speak through boundaryIntoIslandMsg / boundaryOutOfIslandMsg. */
+    boundarySafe(t: IrType): boolean;
+    /** canExitIslandToType with this Lowerer's registries — the EXIT
+     * direction's slightly wider test (bare undefined-armed unions of
+     * JSON-safe data arms exit; the engine's undefined takes the undefined
+     * arm before the JSON round trip). */
+    boundaryExitSafe(t: IrType): boolean;
+    isIslandExpr(node: ts.Expression): boolean;
+    /** True when this node's CHECKER type is `any[]`/`unknown[]` — the type
+     * tsc's Array.isArray predicate narrows readonly arrays to (its `arg is
+     * any[]` quirk), and what a union collapses to when such an arm absorbs
+     * its siblings. The VALUE behind it can still be a real static array
+     * (maybeNarrow's isArray bridge extracts the union's array arm), so
+     * receiver-typed dispatch falls back to the LOWERED type under this
+     * test. */
+    checkerAnyArray(node: ts.Expression): boolean;
+    /** Substitutes a bound type parameter anywhere inside mapType's recursion
+     * (`T`, `T[]`, `{ v: T }`, `(x: T) => T` all resolve). Inert outside
+     * generic instantiation. */
+    readonly typeParamResolver: (t: ts.Type) => IrType | null;
+    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,
+     * assignment, field, return) the shapes must MATCH — TS's structural width
+     * subtyping (`{a, b}` where `{a}` is expected) has no runtime coercion.
+     * Non-record mismatches are not reachable through tsc-clean programs; the
+     * validator ICEs on them as the usual backstop. */
+    requireExactShape(node: ts.Node, actual: IrType, expected: IrType): void;
+    /** Unwraps a HYBRID (function-with-properties) record to its callable:
+     * a record whose shape carries the reserved `%call` func field reads
+     * that field; anything else returns unchanged. The consumer half of
+     * types.ts's chalk-shape mapping — call paths and func-slot coercions
+     * share it. */
+    hybridCallUnwrap(expr: IrExpr): IrExpr;
+    /** The tag of the union arm equal to `arm`, or -1 (unknown union / no
+     * such arm). Arm lists are canonical (typeKey-sorted) and interned, so
+     * 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;
+    /** 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
+     * value's type is one of its arms, wrap it in a `unionWrap` carrying the
+     * arm's canonical tag. Same-union values pass through untouched; anything
+     * else (including a DIFFERENT union) is left for requireExactShape, which
+     * rejects union mismatches with SC2003. */
+    coerceToExpected(expr: IrExpr, expected: IrType): IrExpr;
+    /** Copy-based structural WIDTH coercion — a `Full` record flowing into a
+     * narrower `{ id }` slot, or `Full[]` into `{ id }[]` (the Pick-typed
+     * display-table pattern): TS's width subtyping is free on erased types,
+     * but monomorphic structs must RESHAPE, so the value is rebuilt with the
+     * subset of fields copied — per element, via an interned helper, for
+     * arrays. A deliberate divergence from JS's aliasing (SEMANTICS.md 35,
+     * next to the marshal-copy stance): mutations through the narrowed value
+     * don't reach the original and vice versa. Exactly two flows coerce —
+     * record→record and record-array→record-array, each target field copied
+     * from a same-named source field whose type matches exactly or LIFTS
+     * into the target field's union (see recordWidthHelper); anything
+     * deeper keeps the exactness fences. Null when the pair isn't
+     * width-coercible. */
+    widthCoerce(expr: IrExpr, expected: IrType): IrExpr | null;
+    /** One step of the recursive width-lift relation: how a `src`-typed
+     * value enters a `dst`-typed slot under the copy-reshape family. The
+     * pure planning side — nothing interns here, so whole plans validate
+     * 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)
+     *   wrap      — a non-unit arm value into a union that contains it
+     *   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
+     *               ambiguous and decline)
+     *   width     — record into a strict-subset record (recordWidthPlan,
+     *               recursively — NESTED width)
+     *   arr       — array into array whose element pair lifts (per-element
+     *               copy loop, arrayWidthHelper)
+     * Null when the pair isn't in the relation — callers keep their fences. */
+    widthLiftPlan(src: IrType, dst: IrType): WidthLift | null;
+    /** The build side of widthLiftPlan: the IrExpr converting `value` into
+     * `dst` under a plan the caller validated. Interns whatever helpers the
+     * 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;
+    /** 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
+     * widthLiftPlan — an arm value wraps (`text: string` into
+     * `text?: string`), a whole union re-tags (unionRetagMappable), a field
+     * whose own record/array type needs narrowing reshapes RECURSIVELY
+     * (nested width — the copy stance applies per level), and a MISSING
+     * optional-flavored field completes to its undefined arm (the
+     * literal-completion rule). TUPLES width-coerce too, arity-exact (TS
+     * permits no other tuple width): per-position lifts, never completion.
+     * Index-signature shapes keep the exactness fences here (the overflow
+     * CAPTURE helper owns their reshapes). Null when the shapes don't
+     * relate that way. */
+    /** The pure planning half of recordWidthHelper — every target field's
+     * lift, or null when the pair isn't width-coercible. Callers that must
+     * validate a WHOLE plan before interning anything (the retag helper's
+     * per-arm width lifts) probe with this. */
+    recordWidthPlan(fromId: string, toId: string): Map<string, {
+        src: IrType;
+        lift: WidthLift;
+    } | {
+        absent: true;
+        utag: number;
+    }> | null;
+    recordWidthHelper(fromId: string, toId: string, loc: SrcLoc): string | null;
+    /** Interned `%arr.width.<n>(a)` — the per-element copy loop over
+     * widthLiftPlan's element lift: out = []; n = a.length; for (...)
+     * out.push(lift(a[i])); return out. Record elements reshape
+     * (recordWidthHelper), union elements wrap or re-tag (`number[]` into
+     * `(number | undefined)[]`), nested arrays recurse. Null when the
+     * element pair isn't width-liftable. */
+    /** Interned `%tup.arr.<n>(t)` — rebuilds a TUPLE as an ARRAY: positions
+     * read in order, each lifted into the element type under widthLiftPlan.
+     * Null unless the source shape really is a tuple whose every position
+     * lifts (records with named fields never relate to arrays). */
+    tupleArrayWidthHelper(fromId: string, toT: IrType & {
+        kind: "array";
+    }, loc: SrcLoc): string | null;
+    arrayWidthHelper(fromT: IrType & {
+        kind: "array";
+    }, toT: IrType & {
+        kind: "array";
+    }, loc: SrcLoc): string | null;
+    /** The planning half of objRecordWidthHelper — how a CLASS INSTANCE
+     * projects into a record shape (tsc's structural view of classes makes
+     * `new Point(0,0)` flow into `{x: number; y: number}` slots). Every
+     * target field must be a plain instance FIELD on the class (inherited
+     * included) whose type lifts, or a missing optional-flavored field
+     * completing to its undefined arm — but never a field the class
+     * satisfies through a METHOD or accessor (bound method references have
+     * no lowering; the plan declines instead of projecting a lie). Builtin
+     * runtime layouts (the Error/EventEmitter/stream chains) decline: their
+     * fields aren't plain emitted storage. */
+    objToRecordPlan(className: string, toId: string): Map<string, {
+        src: IrType;
+        lift: WidthLift;
+    } | {
+        absent: true;
+        utag: number;
+    }> | null;
+    /** Interned `%obj.width.<n>(o)` — builds a record from a class
+     * instance's fields under objToRecordPlan: the width-copy stance
+     * (divergence 305 — a fresh record, mutations don't alias, extra class
+     * members drop). */
+    objRecordWidthHelper(className: string, toId: string, loc: SrcLoc): string | null;
+    /** The planning half of recordClassWidthHelper — how a RECORD enters a
+     * class-instance slot. Construction IS the projection, so the class
+     * must be a pure parameter-property data class: its own trivial
+     * constructor (every parameter a parameter property, empty body), no
+     * other fields, no methods/accessors anywhere in the chain (a
+     * fabricated instance must carry no behavior the record lacks), no
+     * decoration, no base beyond a generic FAMILY ancestor (fieldless and
+     * methodless by construction). Each constructor parameter takes the
+     * same-named source field under widthLiftPlan, or — omittable params —
+     * the absent undefined arm. One entry per constructor parameter, in
+     * parameter order. */
+    recordToClassPlan(fromId: string, className: string): ({
+        field: string;
+        src: IrType;
+        lift: WidthLift;
+    } | {
+        absent: true;
+    })[] | null;
+    /** Interned `%cls.width.<n>(r)` — `new C(r.p1, ..., r.pn)` under
+     * recordToClassPlan: the record's fields become the trivial
+     * constructor's arguments (divergence 305's copy stance — a fresh
+     * instance, mutations don't alias, and `instanceof C` answers true
+     * where Node's plain object answers false). */
+    recordClassWidthHelper(fromId: string, className: string, loc: SrcLoc): string | null;
+    /** A CLASS VALUE's statics projected into a record shape (`var f:
+     * ShapeFactory = Shape`): the record literal capturing static FIELDS as
+     * copies of their globals and static METHODS as the zero-capture
+     * closures `const f = C.m` builds (params all required — value-form
+     * completion rules stay out of coercions). Inherited statics resolve
+     * like JS's class-object prototype walk. Divergence 305's copy stance:
+     * later writes to a writable static field don't flow into the record
+     * (Node aliases the one class object). Null when any target field has
+     * no projectable static. */
+    classStaticsProjection(className: string, toId: string, loc: SrcLoc): IrExpr | null;
+    /** Interned `%fn.width.<n>(f)` — the function-RETURN width adapter: a
+     * zero-param `() => Wide[]` value flowing into a `() => Narrow[]` slot
+     * (the createProxyServer getRoutes shape) wraps in a fresh closure that
+     * calls the original and maps the result through the per-element record
+     * width copy (%arr.width). The adapter is a factory lifted function
+     * whose param the returned closure captures; each invocation of the
+     * adapted value builds a FRESH array of narrowed records (the width
+     * machinery's copy stance — callers see the values, not the identity).
+     * Null when the return shapes aren't width-coercible; bounded to
+     * zero-param signatures (the one observed site — widening needs a
+     * param-forwarding story nothing drives yet). */
+    funcReturnWidthAdapter(fromT: IrType & {
+        kind: "func";
+    }, toT: IrType & {
+        kind: "func";
+    }, loc: SrcLoc): string | null;
+    /** Whether a `src`-typed VALUE converts into a `dst` slot through the
+     * coercions coerceToExpected applies mechanically — the PURE probe
+     * behind funcCoerceAdapter (nothing interns): exact types, arm wraps
+     * into unions, whole-union re-tags (unionRetagMappable), checked
+     * single-arm narrows, void into an undefined-armed union, and the dyn
+     * boundary in both directions (dynFrom / dynCheck's JSON-safe domain).
+     * Deliberately EXCLUDES the trap-only stranded conversions — an adapter
+     * that could only ever throw is a fence, not a bridge. */
+    coercibleValue(src: IrType, dst: IrType): boolean;
+    /** Interned `%fn.adapt.<n>(f)` — the GENERAL function-value adapter: a
+     * `fromT` function value flowing into a `toT` slot whose pieces differ
+     * only by coercibleValue conversions. The slot's callers pass toT's
+     * parameters: the wrapper takes them, converts the first
+     * fromT.params.length into the wrapped function's own types (surplus
+     * slot parameters are DROPPED — JS's extra-argument rule), calls it,
+     * and converts the result back (a void slot drops the result; a void
+     * result wraps as the slot union's undefined arm). Rest signatures on
+     * either side decline (the pack shapes don't line up mechanically).
+     * Null when any piece is outside coercibleValue — the exactness fences
+     * stay. */
+    funcCoerceAdapter(fromT: IrType & {
+        kind: "func";
+    }, toT: IrType & {
+        kind: "func";
+    }, loc: SrcLoc): string | null;
+    /** The spawnSync-runner VALUE adapter's plan — a function returning the
+     * opaque spawnRes flowing into a slot whose signature returns the
+     * STRUCTURAL result record tsc accepted (`defaultRunner` into a
+     * `CommandRunner` param: `{ status: number | null; stdout?: string;
+     * stderr?: string; error?: Error }`). Parameters must agree pairwise;
+     * each target field must be one of the spawnRes reads (status, stdout,
+     * stderr, error) at its exact lowered type — string fields optionally
+     * undefined-armed. Null when the pair isn't this shape. Pure: callers
+     * probe before interning. */
+    spawnResFnAdapterPlan(fromT: IrType & {
+        kind: "func";
+    }, toT: IrType & {
+        kind: "func";
+    }): {
+        field: string;
+        build: (r: IrExpr, loc: SrcLoc) => IrExpr;
+    }[] | null;
+    /** Interned `%fnval.spawnres.<n>(f)` — the runner-value adapter: a
+     * fresh closure of the TARGET signature forwarding its arguments to the
+     * captured function and converting the opaque spawnRes result into the
+     * target's structural record (one eager read per declared field —
+     * spawnResFnAdapterPlan's set). Divergence caveat: stdout/stderr read
+     * as the captured text ("" when nothing was captured, e.g. stdio
+     * "inherit") where Node stores null. */
+    spawnResFnAdapter(fromT: IrType & {
+        kind: "func";
+    }, 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. */
+    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,
+     * then `{ data: r }` needs `Buffer | string | Rec` in a `Buffer | string`
+     * slot. Control-flow narrowing to a sub-union erases at lowering, so the
+     * IR value still carries the wide union — but the SITE's checker type
+     * names exactly the arms still possible, and every one of those must
+     * exist in both unions. The stranded arms compile to trap cases exactly
+     * like stranded units (divergence 38's trust-the-checker stance): sound
+     * narrowing never reaches them, a lying cast throws a catchable
+     * TypeError instead of smuggling an unrepresentable arm. Null when the
+     * site type isn't a genuine sub-union of the source (the SC2003 fence
+     * stays). */
+    narrowedRetagHelper(node: ts.Node, fromId: string, toId: string, loc: SrcLoc): string | null;
+    /** The stranded-UNIT trap for PLAIN (non-union) slots: a null/undefined
+     * value flowing into a non-nullable typed slot the checker approved —
+     * `null!` and `null as any as T` casts, and the non-strict world's
+     * legal `let s: string = null`. The compiled representation has no null
+     * to carry, so the FLOW throws the catchable stranded TypeError
+     * (divergence 38's stance: Node lets the impossible value ride until it
+     * is used; the trap surfaces at the assignment instead). Unit sources
+     * only — they are pure, so the nullary helper evaluates nothing. */
+    strandedUnitTrap(expr: IrExpr, expected: IrType, loc: SrcLoc): IrExpr | null;
+    /** The STRANDED-SOURCE trap: a checker-approved value flowing into a
+     * union that cannot represent it (armTag < 0, no class widening, no
+     * width lift). Only shapes that PROVE a lying assertion trap: unit
+     * sources (null/undefined literals smuggled through `null!` / `as any`
+     * casts), and record/array sources with ZERO same-family width-lift
+     * candidates among the arms — an AMBIGUOUS lift (several candidates)
+     * stays a compile fence, because honest code lands there. The interned
+     * helper evaluates the operand (JS evaluates it too) and throws the
+     * stranded-arm TypeError verbatim. Null when the shape doesn't prove
+     * the lie. */
+    strandedCoercionTrap(expr: IrExpr, expected: IrType & {
+        kind: "union";
+    }, loc: SrcLoc): IrExpr | 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
+     * (+1 for ref arms, like any unionNarrow), and every OTHER arm throws
+     * the catchable TypeError — divergence 38's lying-assertion stance (an
+     * unchecked unionNarrow would misread the payload where JS lets the
+     * impossible value flow on). Null when the target isn't a non-unit arm
+     * of the union — those uses keep their erasure/fences. */
+    narrowedArmHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
+    /** True when a static value can become ONE island value: jsval itself,
+     * anything boundary-safe (the deep JSON marshal), a record whose fields
+     * all can (built as an island OBJECT literal, field by field), or an
+     * array of such (built as an island ARRAY, element by element). The
+     * lift beyond boundarySafe exists for jsval-BEARING composites —
+     * `{ role: string; content: any[] }[]` flowing into an `any[]` slot —
+     * which have no JSON serialization (a handle isn't JSON) but an honest
+     * per-field construction. Recursion terminates: recursive shapes are
+     * rejected at mapping time. */
+    jsvalLiftable(t: IrType): boolean;
+    /** A jsval-typed expression carrying `e`'s value into the island —
+     * jsvalLiftable's constructive side. Primitives and JSON-safe composites
+     * keep the jsMarshal deep copy; jsval-bearing records and arrays go
+     * through interned per-type builder helpers (%jsin.*), so the operand is
+     * always evaluated exactly once (as the helper's argument). */
+    jsvalLiftExpr(e: IrExpr, loc: SrcLoc): IrExpr;
+    /** Interned `%jsin.union.<n>(u)` — the runtime tag switch marshaling a
+     * union value INTO the island: unit arms become the engine's own
+     * undefined/null (JS-exact — `{ instructions: undefined }` crossing in
+     * has the property present and undefined, exactly what the source
+     * spells), every other arm narrows and lifts as itself (strings by
+     * value, JSON-safe composites as deep copies, typed arrays as engine
+     * typed-array copies, URLs as engine URL instances). Caller must have
+     * checked jsvalLiftable. */
+    unionToJsvalHelper(unionId: string, loc: SrcLoc): string;
+    /** Interned `%jsin.rec.<n>(r)` — builds an island OBJECT from a
+     * jsval-bearing record: marshaled key strings, each field lifted through
+     * jsvalLiftExpr (jsval fields pass as handles, JSON-safe fields deep-copy,
+     * nested composites recurse through their own helpers). Caller must have
+     * checked jsvalLiftable. */
+    recordToJsvalHelper(shapeId: string, loc: SrcLoc): string;
+    /** Interned `%jsin.arr.<n>(a)` — builds ONE island ARRAY from a native
+     * array whose elements lift: out = []; for (...) out[i] = lift(a[i]);
+     * return out. The index marshals by value like any number. Caller must
+     * have checked jsvalLiftable of the element. */
+    arrayToJsvalHelper(elem: IrType, loc: SrcLoc): string;
+    /** Interned `%jsin.elems.<n>(a)` — a NATIVE array of island handles from
+     * a native array whose elements lift: the `any[]`-slot coercion (each
+     * element becomes one island value; the array stays static). Null when
+     * the element doesn't lift. */
+    arrayToJsvalArrayHelper(fromElem: IrType, loc: SrcLoc): string | null;
+    jsvalIn(e: IrExpr, node: ts.Node): IrExpr;
+    /** THE coercion path for values flowing into a typed slot: union arms
+     * 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. */
+    coerceInto(node: ts.Node, expr: IrExpr, expected: IrType): IrExpr;
+    /** The unit an 'any' expression PROVABLY holds on every run, or null
+     * when no proof exists. Two spellings prove: the lowered value IS the
+     * engine unit literal (`null as any`, an any-contextual `undefined`),
+     * or the node is an identifier whose every declaration is a plain,
+     * non-ambient `var`/`let`/`const` declarator under a variable STATEMENT
+     * (catch bindings, for-of/for-in cursors, parameters, and imports all
+     * fail this shape test — each receives values from elsewhere), each
+     * initializer absent or unit-typed by the checker (a unit TYPE has
+     * exactly one value, so syntax doesn't matter), and nothing in the
+     * declaring file ever assigns it — bindingNeverReassigned, the same
+     * file-scan proof the generic-binding machinery leans on (ESM import
+     * bindings are read-only, so cross-file writes don't exist). A hoisted
+     * `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. */
+    lowerExprExpecting(node: ts.Expression, expected: IrType | undefined): IrExpr;
+    /** 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 DOM conversion: dyn values pass
+     * through, JSON-safe static values convert with dynFrom (a deep copy —
+     * the jsMarshal aliasing stance), everything else keeps the dyn-boundary
+     * fence. Typed slots ride the ordinary coercion path (union slots wrap
+     * arm values, exactness enforced). */
+    intoIndexValueSlot(value: IrExpr, indexValue: IrType, node: ts.Node): IrExpr;
+    /** IR-level `t | undefined` through the shared canonicalizer — the
+     * declared result type of an index-signature read under
+     * noUncheckedIndexedAccess. Null when the type cannot take the arm. */
+    withUndefinedArmOf(t: IrType): IrType | null;
+    /** True when a static type converts to a dyn DOM value (the dynFrom
+     * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the DOM's
+     * bytes kind, payload copied; stdin chunks into unknown-typed helpers),
+     * an undefined-armed union whose other arms are JSON-safe — the
+     * undefined arm becomes the undefined DOM singleton — or a BOXABLE
+     * function type (the checked-dynamic function boundary: the closure
+     * crosses as the DOM's callable kind, identity preserved). */
+    dynConvertible(t: IrType): boolean;
+    /** The value of a `return` statement. In an async function `return p`
+     * where p is a promise flattens (JS: the returned promise's settlement
+     * becomes the async function's result), so it lowers exactly as
+     * `return await p` — the awaitExpr parks the fiber and re-throws
+     * rejections, which IS the flattening. Everything else flows into the
+     * function's return slot through the usual coercion path. */
+    /** The value of `return <expr>` against the context's declared return —
+     * or NULL for a bare return: `return undefined`/`return null` in a
+     * void-returning function (`{ bar() { return undefined } }`, inferred
+     * `() => null` shapes whose return maps to void) hands the caller JS's
+     * undefined, which the void slot drops. Units are pure literals, so
+     * nothing evaluates; unit-typed non-literals keep the fences. */
+    lowerReturnValue(node: ts.Expression): IrExpr | null;
+    /** `return <expr>` lowered as a STATEMENT against the declared return.
+     * Void-returning contexts get the JS drop: a contextually void-typed
+     * function may return a value (`fv = function() { return 0; }` into a
+     * `() => void` slot) — the expression evaluates for its effects, the
+     * caller never sees a value, so the return goes out bare. Async
+     * void-inner returns still resolve a returned promise first. */
+    lowerReturnStmt(node: ts.Expression, loc: SrcLoc): IrStmt;
+    maybeNarrow(expr: IrExpr, node: ts.Node): IrExpr;
+    lowerUnitComparison(left: IrExpr, right: IrExpr, negated: boolean, loc: SrcLoc): IrExpr | null;
+    lowerNullishCoalesce(expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
+    lowerOptionalChain(expr: ts.CallExpression | ts.PropertyAccessExpression | ts.ElementAccessExpression): IrExpr;
+    finishOptionalChain(expr: ts.Expression, id: string, receiver: IrExpr, body: IrExpr, loc: SrcLoc): IrExpr;
+    /** The union without `t`'s undefined arm (unchanged when there is none, or
+     * when `t` isn't a union). The body-facing type of a defaulted parameter:
+     * tsc types uses of `x: string | undefined = "hi"` as plain `string` inside
+     * the body — the default removes exactly the undefined possibility. */
+    stripUndefinedArm(t: IrType): IrType;
+    /** The interned `T | undefined` union over a non-union arm type — the ABI
+     * type of a defaulted parameter, and the result type of lookups that may
+     * miss (process.env reads). "undefined" sorts last among all arm typeKeys,
+     * so the sorted pair is always [t, undefined]. */
+    withUndefinedArm(t: IrType): IrType;
+    paramShape(param: ts.ParameterDeclaration): ParamShape;
+    checkDefaultParamBodyType(param: ts.ParameterDeclaration, bodyType: IrType): void;
+    paramShapes(params: readonly ts.ParameterDeclaration[]): ParamShape[];
+    completeArgs(argNodes: readonly ts.Expression[], shapes: readonly ParamShape[], loc: SrcLoc, blame: ts.Node): IrExpr[];
+    wrappedUndefined(type: IrType, loc: SrcLoc): IrExpr | null;
+    /** The entry value of a binding JS initializes to `undefined` (an
+     * initializer-less declaration, a hoisted `var` before its statement):
+     * undefined-armed unions hold the interned undefined arm, and 'any'
+     * slots hold the ENGINE's undefined — tsc's definite-assignment
+     * analysis never guards `any` reads, so a jsval slot IS readable before
+     * any assignment and must never stay a C-level NULL (a validated exit
+     * or engine op on NULL is memory-unsafe, not a TypeError). Null for
+     * every other type: tsc rejects their pre-assignment reads. */
+    unassignedSlotInit(type: IrType, loc: SrcLoc): IrExpr | null;
+    undefinedArgFor(type: IrType, loc: SrcLoc, blame: ts.Node): IrExpr;
+    requireExactArityValue(blame: ts.Node, contextual: ts.Expression | null, shapes: readonly ParamShape[], funcType: IrType): void;
+    bodyReturnType(isAsync: boolean, declared: IrType): IrType;
+    genBodyReturnType(declared: IrType): IrType;
+    declaredReturnType(decl: ts.SignatureDeclaration, blame: ts.Node): IrType;
+    /** Runs one declaration's collection with diagnostics captured: on
+     * poison, they DEFER under the declaration's symbol instead of failing
+     * the build — an unreached broken declaration costs nothing; the first
+     * reference flushes them (flushDeferred). A declaration with no name
+     * symbol reports eagerly (nothing could ever reference it). */
+    collectDeferring(symbolOf: () => ts.Symbol | undefined, collect: () => void): ts.Symbol | null;
+    /** Pushes a symbol's deferred collection diagnostics: lowering resolved
+     * a reference to it, so the declaration is part of what the entry runs.
+     * The reference site then proceeds exactly as before (its own rejection
+     * may follow) — reached-but-broken declarations report the same set of
+     * diagnostics the eager collector historically produced. */
+    flushDeferred(symbol: ts.Symbol): void;
+    flushDeferredClass(className: string): void;
+    collectSignature(decl: ts.FunctionDeclaration): void;
+    collectSignatureInner(decl: ts.FunctionDeclaration): void;
+    collectGenericSignature(decl: ts.FunctionDeclaration): void;
+    genericFnOf(ident: ts.Identifier): GenericFnInfo | null;
+    lowerGenericCall(expr: ts.CallExpression, info: GenericFnInfo): IrExpr;
+    lowerGenericFnValue(ref: ts.Expression, info: GenericFnInfo): IrExpr;
+    inferTypeParamBindings(expr: ts.CallExpression, info: GenericFnInfo, rsig: ts.Signature): Map<ts.Symbol, IrType>;
+    lowerGenericInstance(info: GenericFnInfo, inst: GenericInstance): IrFunction;
+    collectClassShape(decl: ts.ClassDeclaration): void;
+    collectClassShapeInner(decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
+        family: ClassInfo;
+        name: string;
+        bindings: Map<ts.Symbol, IrType>;
+        typeArgsText: string;
+        ordinal: number;
+    }, mixin?: {
+        base: ClassInfo;
+        name: string;
+        call: ts.CallExpression;
+        bindings: Map<ts.Symbol, IrType>;
+        context: string;
+        ordinal: number;
+    }): void;
+    lowerClassExpressionInfo(expr: ts.ClassExpression): ClassInfo;
+    lowerClassExpression(expr: ts.ClassExpression): IrExpr;
+    findMethodOn(info: ClassInfo | null, name: string): {
+        declarer: ClassInfo;
+        sig: {
+            params: ParamShape[];
+            ret: IrType;
+            abstract?: true;
+            async?: true;
+        };
+    } | null;
+    isSubclassOf(sub: string, sup: string): boolean;
+    inHierarchy(info: ClassInfo): boolean;
+    overrideBelow(info: ClassInfo, name: string): boolean;
+    upcastTo(expr: IrExpr, className: string): IrExpr;
+    /** True when `className` is the %Error root or any class inside its
+     * hierarchy (builtin kinds and user `extends Error` subclasses). */
+    errorHierarchyClassOf(className: string): boolean;
+    classValueRef(info: ClassInfo, blame: ts.Node): IrExpr;
+    /** Class EXPRESSIONS collected this run, in first-encounter order: the
+     * emit pass lowers their members after the init bodies (declaration
+     * members ride fp.classDecls; expressions register only when their
+     * containing statement lowers). */
+    readonly exprClasses: ClassInfo[];
+    readonly exprClassInfoByNode: Map<ts.ClassExpression, ClassInfo>;
+    /** Class expressions whose collection is IN FLIGHT — the reentrancy
+     * guard for heritage-demanded collection (lowerClassExpressionInfo). */
+    readonly collectingExprClasses: Set<ts.ClassExpression>;
+    /** 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[];
+    /** 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. */
+    onExprClassCollected: ((info: ClassInfo) => 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). */
+    readonly mixinFnShapes: Map<ts.Node, 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. */
+    readonly mixinInstanceByCall: Map<ts.CallExpression, ClassInfo | null>;
+    /** Mixin calls whose instantiation is IN FLIGHT — the cyclic-extends
+     * backstop (the collectingExprClasses rule). */
+    readonly mixinCollectingCalls: Set<ts.CallExpression>;
+    /** Per mixin-class-node demand count: only the FIRST instantiation
+     * counts statements toward coverage (the generic-instance rule). */
+    readonly mixinOrdinals: Map<ts.ClassLikeDeclaration, number>;
+    /** The mixin instantiation whose source is CURRENTLY collecting or
+     * lowering: mapType resolves the inner class node's own instance type
+     * (`this` inside members, self-referential fields) to THIS
+     * instantiation — the shared AST means the checker keeps answering the
+     * one class node for every instantiation, like generic bindings. */
+    mixinTypeContext: {
+        classNode: ts.ClassLikeDeclaration;
+        className: string;
+    } | null;
+    /** PINNED mixin instantiations (const-binding / heritage call sites) by
+     * their class node — the intersection resolver's candidate sets
+     * (mixinIntersectionInstanceType). */
+    readonly mixinInstancesByClassNode: Map<ts.ClassLikeDeclaration, ClassInfo[]>;
+    mixinCallClassInfoOf(call: ts.CallExpression): ClassInfo | null;
+    /** Generic classes (monomorphization by flow): declaration → the family's
+     * instance table. Filled by collectClassShapeInner's family mode;
+     * consulted by mapType's genericClassInstance hook. */
+    readonly genericClassByDecl: Map<ts.ClassLikeDeclaration, GenericClassInfo>;
+    /** Instantiations in demand order — the member-lowering worklist run()'s
+     * monomorphization fixpoint drains (an instantiation's methods can
+     * demand further instances of either kind). */
+    readonly genericClassInstances: ClassInfo[];
+    /** Discovery hook: a generic-class instantiation collected mid-lowering
+     * (instantiations are demand-driven, not units — their members lower in
+     * the instance drain). Null everywhere today; reserved for symmetry with
+     * onExprClassCollected should instantiations ever need eager
+     * registration. */
+    onLateClassCollected: ((info: ClassInfo) => void) | null;
+    genericClassInstanceType(decl: ts.ClassLikeDeclaration, ref: ts.Type): IrType | null;
+    findStaticOn(info: ClassInfo | null, name: string): ReturnType<typeof findStaticOn>;
+    staticShadowBelow(info: ClassInfo, name: string): boolean;
+    ctorAbiEquals(sub: ClassInfo, sup: ClassInfo): boolean;
+    exactClassOfReceiver(expr: ts.Expression): ClassInfo | null;
+    lowerClassMembers(info: ClassInfo): IrFunction[];
+    lowerStaticFieldInits(info: ClassInfo): IrStmt[];
+    /** The method-like members (methods and accessors) of a class that have
+     * lowerable bodies, with their collected method-map names. */
+    classMethodMembers(info: ClassInfo): Generator<{
+        mName: string;
+        member: ts.MethodDeclaration | ts.AccessorDeclaration;
+    }>;
+    lowerClassCtor(info: ClassInfo): IrFunction;
+    lowerClassMethodMember(info: ClassInfo, fnLike: ts.MethodDeclaration | ts.AccessorDeclaration): IrFunction | null;
+    throwingSetterFn(info: ClassInfo, prop: string): IrFunction;
+    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. */
+    declareThis(type: IrType): IrLocal;
+    lowerFunction(decl: ts.FunctionDeclaration): IrFunction | null;
+    collectGlobals(sf: ts.SourceFile, topStmts: ts.Statement[]): void;
+    lowerFileInit(sf: ts.SourceFile, stmts: ts.Statement[], name: string): IrFunction;
+    lowerDefaultExport(stmt: ts.ExportAssignment): IrStmt | null;
+    buildMain(): IrFunction;
+    declareLocal(nameNode: ts.Node, name: string, type: IrType, mutable: boolean): IrLocal;
+    /** A function-scope local bound to NO ts.Symbol — the hidden ABI slot of a
+     * defaulted parameter (the parameter's symbol binds to the separately-
+     * declared body local; nothing in the source can name this one). */
+    declareHiddenLocal(name: string, type: IrType): IrLocal;
+    /** Declares a callee's parameter locals from its ParamShapes and builds
+     * the DEFAULT-PARAM PROLOGUE. Required/optional/rest params bind their
+     * symbol directly (one local of the ABI type). A defaulted param `x: T = e`
+     * gets TWO locals: the hidden ABI slot (the incoming `T | undefined`
+     * union) and the body local `x` of plain T, initialized by
+     *
+     *   const x = <in> is undefined-arm ? e : narrow(<in>)
+     *
+     * — a lazily-branched ternary, so the default expression evaluates exactly
+     * when the argument was omitted or undefined (JS's call-time rule), in the
+     * callee scope, left-to-right across params (prologue order), and may
+     * reference earlier params (their body locals are already bound) and
+     * `this` in methods (param 0, declared before any of these). tsc rejects
+     * self- and forward-references inside initializers. Must be called before
+     * lowering the body; the returned prologue statements go first. */
+    declareParams(rawDecls: readonly ts.ParameterDeclaration[], shapes: readonly ParamShape[]): {
+        params: IrParam[];
+        prologue: IrStmt[];
+    };
+    /** The binding for `symbol` inside context `ctx` — a scoped local or an
+     * already-threaded capture entry. */
+    bindingIn(ctx: FnCtx, symbol: ts.Symbol): 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
+     * resolved here — callers check `isSelfReference` first. */
+    resolveLocal(ident: ts.Identifier): IrLocal | null;
+    /** Lexical `this` — the enclosing method's this-param, possibly captured
+     * through arrows (function expressions/declarations reset `this` in JS;
+     * their bodies never see an enclosing method's binding). */
+    resolveThis(): IrLocal | null;
+    resolveKey(symbol: ts.Symbol, blame?: ts.Node): IrLocal | null;
+    isSelfReference(ident: ts.Identifier): boolean;
+    lowerStmts(stmts: readonly ts.Statement[]): IrStmt[];
+    noteBlockedBindings(stmt: ts.Statement): 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
+     * caller's own fallback otherwise. */
+    rejectUnresolved(ident: ts.Identifier, fallback: string): never;
+    rejectUnresolvedSymbol(symbol: ts.Symbol | null, name: string, node: ts.Node, fallback: string): never;
+    lowerScopedBlock(stmt: ts.Statement): IrStmt[];
+    /** Lowers inside a control-construct marker (loop/switch/labeled block/
+     * try-with-finally/finally block) so the jump fences below know what a
+     * break/continue/return crosses. `labels` carries the construct's JS
+     * label names when the source statement was labeled — labeled jumps
+     * resolve against them. */
+    inCtl<T>(kind: "loop" | "switch" | "block" | "tryFinally" | "finallyBlock", fn: () => T, labels?: string[]): T;
+    /** The label names a `lbl:` chain put on the statement currently being
+     * lowered — set by lowerLabeled around lowering the labeled construct,
+     * consumed exactly once by the construct's own lowering (takeLabels).
+     * A lowering that never consumes them signals lowerLabeled to fence:
+     * silently dropping a label would compile `break lbl` wrong. */
+    pendingLabels: string[] | null;
+    takeLabels(): string[] | undefined;
+    rejectJumpCrossingFinally(kw: "break" | "continue" | "return", stmt: ts.Statement, label?: string): void;
+    lowerStmt(stmt: ts.Statement): IrStmt | IrStmt[] | null;
+    lowerVarStatement(stmt: ts.VariableStatement): IrStmt[];
+    lowerDestructuringDecl(decl: ts.VariableDeclaration, isLet: boolean): IrStmt[];
+    lowerDestructuringAssignParts(target: ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, rhs: ts.Expression, loc: SrcLoc): {
+        stmts: IrStmt[];
+        value: IrExpr;
+    };
+    lowerBindingPattern(pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[]): void;
+    checkBindingElement(el: ts.BindingElement, allowDefault?: boolean): void;
+    bindPatternTarget(name: ts.BindingName, value: IrExpr, isLet: boolean, out: IrStmt[]): void;
+    lowerVarDeclList(list: ts.VariableDeclarationList): IrStmt | null;
+    lowerVarDecl(decl: ts.VariableDeclaration, isLet: boolean): IrStmt | null;
+    lowerSwitch(stmt: ts.SwitchStatement): IrStmt;
+    lowerTry(stmt: ts.TryStatement): IrStmt;
+    lowerExprStatement(expr: ts.Expression): IrStmt;
+    lowerForOf(stmt: ts.ForOfStatement): IrStmt;
+    lowerForStatement(stmt: ts.ForStatement): IrStmt;
+    lowerCondition(expr: ts.Expression): IrExpr;
+    ensureBool(e: IrExpr, node: ts.Expression): IrExpr;
+    requireTruthyUnion(unionId: string, node: ts.Expression): void;
+    eqComparableUnion(unionId: string): boolean;
+    lowerExpr(expr: ts.Expression): IrExpr;
+    lowerIntrinsicProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    /** True for the STANDARD LIBRARY's source files: the shipped ambient
+     * .d.ts files (core + overrides + fallback), a lib.*.d.ts bundled with the typescript
+     * package (asked via program.isSourceFileDefaultLibrary, never by path
+     * matching), or the ADOPTED @types/node surface standing in for the
+     * fallback (see loadProgram — the lowering tables recognize the same
+     * members by name + this provenance, and everything else those files
+     * declare hits the SC2020-family fence). The file half of every
+     * supported-surface provenance check. */
+    readonly isStdlibFile: (sf: ts.SourceFile) => boolean;
+    nodeTypesOnlySymbol(sym: ts.Symbol | null | undefined): boolean;
+    /** True for an npm package's shipped declaration files — under
+     * node_modules but NOT the standard library (typescript's own lib files
+     * live under node_modules too), or inside a registered workspace-linked
+     * package (a node_modules symlink whose realpath'd files carry no
+     * node_modules segment — shared.ts). The provenance half of the npm
+     * typing rule (package types are island handles) and of the per-package
+     * requires-dynamic attribution. */
+    readonly isNpmFile: (sf: ts.SourceFile) => boolean;
+    npmPackageOf(type: ts.Type): string | null;
+    npmMemberFence(access: ts.PropertyAccessExpression): void;
+    npmPackageOfSymbol(sym: ts.Symbol | undefined): string | null;
+    isStdlibMember(access: ts.PropertyAccessExpression): boolean;
+    isStdlibSymbol(symbol: ts.Symbol | undefined): boolean;
+    isStdlibGlobal(expr: ts.Expression, name: string): boolean;
+    stdlibGlobalMember(access: ts.PropertyAccessExpression, name: string): string | null;
+    lowerArrayLiteral(expr: ts.ArrayLiteralExpression, expected?: IrType & {
+        kind: "array";
+    }): IrExpr;
+    lowerObjectLiteral(expr: ts.ObjectLiteralExpression): IrExpr;
+    lowerShorthandValue(prop: ts.ShorthandPropertyAssignment): IrExpr;
+    rejectThisInObjectMethod(node: ts.Node): void;
+    lowerElementAccess(expr: ts.ElementAccessExpression): IrExpr;
+    lowerRecordKeyRead(expr: ts.ElementAccessExpression, shapeId: string, shape: IrRecordShape): IrExpr;
+    lowerElementWrite(expr: ts.BinaryExpression): IrStmt;
+    ensureString(e: IrExpr, node: ts.Node): IrExpr;
+    lowerTemplate(expr: ts.TemplateExpression): IrExpr;
+    lowerAsExpression(expr: ts.AsExpression | ts.TypeAssertion): IrExpr;
+    lowerPrefixUnary(expr: ts.PrefixUnaryExpression): IrExpr;
+    lowerBinary(expr: ts.BinaryExpression): IrExpr;
+    lowerCaughtTypeofTest(expr: ts.BinaryExpression, loc: SrcLoc): IrExpr | null;
+    caughtRead(node: ts.Identifier, local: IrLocal, loc: SrcLoc): IrExpr;
+    caughtLocalOf(node: ts.Expression): IrLocal | null;
+    caughtToString(node: ts.Expression): IrExpr | null;
+    lowerInstanceOf(expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
+    lowerCall(expr: ts.CallExpression): IrExpr;
+    isTopLevelFnSymbol(ident: ts.Identifier): boolean;
+    lowerNestedFunctionDecl(stmt: ts.FunctionDeclaration): IrStmt;
+    lambdaSignature(node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): {
+        shapes: ParamShape[];
+        funcType: IrType & {
+            kind: "func";
+        };
+    };
+    lowerLambda(node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): IrExpr;
+    lowerArrayMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerMapMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerMapForEachCall(call: ts.CallExpression, receiver: IrExpr, mapT: IrType & {
+        kind: "map";
+    }): IrExpr;
+    buildMapForEachFn(name: string, mapT: IrType & {
+        kind: "map";
+    }, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
+    lowerSetMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerSetForEachCall(call: ts.CallExpression, receiver: IrExpr, setT: IrType & {
+        kind: "set";
+    }): IrExpr;
+    buildSetForEachFn(name: string, setT: IrType & {
+        kind: "set";
+    }, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
+    lowerRegexLiteral(expr: ts.RegularExpressionLiteral): IrExpr;
+    lowerRegexMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerStringMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerBytesNew(expr: ts.NewExpression, symbol: ts.Symbol | null | undefined): IrExpr | null;
+    lowerBytesMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerBufferStaticCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    fieldTarget(access: ts.PropertyAccessExpression): FieldTarget | null;
+    uniqueSymbolKeyOf(key: ts.Expression): {
+        sym: ts.Symbol;
+        fieldName: string;
+    } | null;
+    foldedStringKeyOf(expr: ts.Expression): string | null;
+    accessorCall(className: string, member: string, obj: IrExpr, extraArgs: IrExpr[], ret: IrType, loc: SrcLoc): IrExpr;
+    classIteratorOf(t: IrType): ClassIteratorInfo | null;
+    classIteratorOpenCall(cit: ClassIteratorInfo, recv: IrExpr, loc: SrcLoc): IrExpr;
+    classIteratorNextCall(cit: ClassIteratorInfo, itRef: IrExpr, loc: SrcLoc): IrExpr;
+    classIteratorDrainCall(src: IrExpr, loc: SrcLoc, elemT?: IrType): IrExpr | null;
+    classIteratorRestDrainCall(cit: ClassIteratorInfo, itVal: IrExpr, loc: SrcLoc): IrExpr;
+    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;
+    inheritsBuiltinErrorCtor(info: ClassInfo): boolean;
+    inheritsBuiltinEmitterCtor(info: ClassInfo): boolean;
+    lowerNew(expr: ts.NewExpression): IrExpr;
+    lowerFieldRead(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerUnionProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerRecordFieldCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerObjectMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerSuperMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr;
+    superThisRef(access: ts.PropertyAccessExpression): {
+        thisRef: IrExpr;
+        base: ClassInfo;
+    };
+    lowerSuperAccessorRead(access: ts.PropertyAccessExpression): IrExpr;
+    lowerSuperAccessorWrite(access: ts.PropertyAccessExpression, rhs: ts.Expression, loc: SrcLoc): IrStmt;
+    lowerComptime(expr: ts.CallExpression): IrExpr;
+    comptimeBakeable(t: IrType): boolean;
+    rejectComptimeCaptures(cb: ts.ArrowFunction | ts.FunctionExpression): void;
+    comptimeValueToIr(value: unknown, expected: IrType, path: string, blame: ts.Node): IrExpr;
+    isConsoleLog(call: ts.CallExpression): boolean;
+    consoleCallMember(call: ts.CallExpression): "log" | "error" | "warn" | null;
+    builtinImportOf(ident: ts.Identifier): {
+        module: string;
+        member: string;
+    } | null;
+    /** The namespace-import twin of builtinImportOf's provenance rule:
+     * resolves an expression to the supported builtin MODULE whose members
+     * it exposes — an identifier declared by `import * as ns from "node:fs"`
+     * (through the symbol, so shadowing locals never match), or a nested
+     * member access that IS a module in its own right (`fs.promises` — the
+     * same object as node:fs/promises, Node's rule). Null otherwise. */
+    builtinNamespaceModuleOf(expr: ts.Expression): string | null;
+    /** A member access on a supported builtin namespace import —
+     * `fs.readFileSync`, `path.sep`, `fs.promises.readFile` — as the same
+     * { module, member } shape builtinImportOf gives named imports, so both
+     * import forms key the same lowering tables. Null for everything else. */
+    builtinMemberOf(access: ts.PropertyAccessExpression): {
+        module: string;
+        member: string;
+    } | null;
+    /** `ns.member(...)` on a builtin namespace import: exactly the named-
+     * import dispatch — the module tables for lowered members, the module-
+     * qualified per-member fence for the rest. Null for non-namespace
+     * callees (the call chain keeps trying). */
+    lowerNamespaceBuiltinCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    /** `ns.member` on a builtin namespace import as a VALUE: constants
+     * (path.sep, os.EOL) read as interned string literals; fs.constants
+     * access-mode bits bake as numbers exactly like the named-import form;
+     * functions have no closure representation (call sites only); members
+     * with no lowering fence with the module-qualified name. Null for
+     * non-namespace receivers (the property chain keeps trying). */
+    lowerNamespaceBuiltinProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerBuiltinModuleCall(expr: ts.CallExpression, bi: {
+        module: string;
+        member: string;
+    }, fn: BuiltinModuleFn, loc: SrcLoc): IrExpr;
+    lowerChildArgsArg(node: ts.Expression | undefined, loc: SrcLoc): IrExpr;
+    lowerSpawnSyncCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+    lowerSpawnCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+    lowerExecSyncCall(expr: ts.CallExpression, shell: boolean, loc: SrcLoc): IrExpr;
+    recordToEnvPairs(node: ts.Expression): IrExpr;
+    envToPairsHelper(shapeId: string, loc: SrcLoc): string | null;
+    lowerJsonMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    fencedBuiltinImportOf(ident: ts.Identifier): string | null;
+    lowerCryptoComposedCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerUrlMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerSearchParamsMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerStatsMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerChildMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerAtomicsCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerNetModuleCall(expr: ts.CallExpression, bi: {
+        module: string;
+        member: string;
+    }, loc: SrcLoc): IrExpr | null;
+    lowerServerMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerServerProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerAssertModuleCall(expr: ts.CallExpression, bi: {
+        module: string;
+        member: string;
+    }, loc: SrcLoc): IrExpr | null;
+    lowerAssertDirectCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr | null;
+    lowerUtilModuleCall(expr: ts.CallExpression, bi: {
+        module: string;
+        member: string;
+    }, loc: SrcLoc): IrExpr | null;
+    lowerDgramDnsModuleCall(expr: ts.CallExpression, bi: {
+        module: string;
+        member: string;
+    }, loc: SrcLoc): IrExpr | null;
+    lowerDgramMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerNodeTestModuleCall(expr: ts.CallExpression, bi: {
+        module: string;
+        member: string;
+    }, loc: SrcLoc): IrExpr | null;
+    lowerTestDirectCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr | null;
+    lowerTestMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerTestCtxProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerHttpHeadersElement(expr: ts.ElementAccessExpression): IrExpr | null;
+    lowerJsonProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerErrorCodeProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerStringDecoderMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerReadlineMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerDcChannelMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerAlsMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerDcChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerDcTracingChannelMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerDcTracingChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
+    strdecHelper(op: "write" | "end", shapeId: string, loc: SrcLoc): string;
+    lowerProcessProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerFsConstantsProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerHttp2ConstantsProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    http2ConstantBindingOf(ident: ts.Identifier): IrExpr | null;
+    http2ConstantsDestructureDecl(nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+    lowerProcessStreamProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    isProcessEnv(node: ts.Expression): boolean;
+    envValueType(): IrType;
+    lowerProcessEnvGet(expr: ts.PropertyAccessExpression): IrExpr | null;
+    lowerProcessMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerProcessOptionalMethodCall(call: ts.CallExpression): IrExpr | null;
+    lowerTimeoutMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    promisifiedExecFileDecl(nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+    lowerExecFileAsyncCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+    execFileAsyncHelper(loc: SrcLoc): {
+        name: string;
+        shapeId: string;
+    };
+    envSnapshotHelper(shapeId: string, loc: SrcLoc): string | null;
+    lowerNumberStaticCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerDateCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerTextCodecCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerStringStaticCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerStringLastIndexOfCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerFilterNarrowCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerPromiseMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerPromiseStaticCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerNumberStaticProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    requireDynamicApi(feature: string, node: ts.Node): void;
+    lowerMathProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
+    islandGlobalFnOf(ident: ts.Identifier): IslandFnEntry | null;
+    lowerIslandMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+}