@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,4 +1,9 @@
+import type { ConstructorReturnPlan } from "./constructor-returns.js";
 import { type CycleInitFlag } from "./cycle-initialization.js";
+import { type JsonRequireModule } from "./json-require.js";
+import { type EarlyReference, type RequireInitFlag } from "./require-initialization.js";
+import { KeyOrderNotes } from "./key-order-witness.js";
+import { type WasmModuleReport } from "../../wasm/discover.js";
 import type { FieldLift } from "./coercions/structural-plans.js";
 import { CoercionState } from "./coercions/state.js";
 import { NarrowingStability } from "./narrowing-stability.js";
@@ -10,8 +15,10 @@ import type { WidthLift } from "./width-lift.js";
 import { type FnCtx } from "./function-context.js";
 import type { FrontendServices } from "../services.js";
 import { type ProtocolDispatch } from "./class-protocol-dispatch.js";
+import { type DynamicFunction } from "../../ir/tiers.js";
+import { type TierMode, type TierReport } from "../tier-analysis.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
-import type { ClassSymbolKey } from "./symbol-fields.js";
+import { type ClassSymbolKey } from "./symbol-fields.js";
 import type { HttpClientFnBinding } from "./lower-server.js";
 export type { WidthLift } from "./width-lift.js";
 export { newFnCtx, type FnCtx } from "./function-context.js";
@@ -20,9 +27,10 @@ import { type UnionLiteral } from "../union-discriminants.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { UNSUPPORTED } from "../../diagnostics/diagnostic.js";
 import type { IrClassDef, IrExpr, IrFfiImport, IrFunction, IrGlobal, IrLocal, IrModule, IrParam, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
-import { type StartupCrash } from "../program.js";
+import { type StartupCrash, type CycleEdge } from "../program.js";
 import { ShapeRegistry, type TypeMapperCtx, UnionRegistry } from "../type-mapper.js";
 import { type CompoundOp, type StdlibFnEntry, type BuiltinModuleFn } from "./surfaces.js";
+import { type BuiltinClassRef } from "./builtins/class-values.js";
 import { type FileParts } from "./lower-modules.js";
 import { type ClassInfo, type ClassIteratorInfo, type GenericClassInfo, findStaticOn } from "./lower-classes.js";
 import { type MixinFnShape } from "./lower-mixins.js";
@@ -62,6 +70,12 @@ export type StaticCallableProjection = {
 } | {
     kind: "promisified-zlib";
     member: string;
+} | {
+    kind: "promisified-crypto";
+    member: string;
+} | {
+    kind: "promisified-dns";
+    member: string;
 };
 /** Own-property lookup for the surface tables. They are plain object
  * literals, so a bare `table[name]` would also find Object.prototype
@@ -76,6 +90,9 @@ export interface LowerStats {
     statementsFailed: number;
     /** Functions whose signature couldn't be analyzed (bodies not counted). */
     functionsSkipped: number;
+    /** Coverage only: reached statements that compile into dynamic-tier
+     * functions (tier-analysis.ts), a subset of the compiled statements. */
+    statementsDynamic?: number;
 }
 /** Every identifier a binding name binds: the identifier itself, or all
  * identifiers of a (possibly nested) destructuring pattern in source
@@ -113,18 +130,29 @@ export interface LowerResult {
         stats: LowerStats;
         runtimeFences?: ScrDiagnostic[];
     };
+    /** Coverage only: the WebAssembly modules the build can see (wasm/discover.ts). */
+    wasmModules?: WasmModuleReport[];
     /** Compile-time-detectable behavior differences from Node (SC6xxx
      * divergence warnings) in the program's own modules. Never failures. */
     divergences?: ScrDiagnostic[];
+    /** Functions lowering placed in the dynamic tier (ir/tiers.ts), present
+     * when there are any. */
+    dynamicFunctions?: DynamicFunction[];
+    /** LowerOptions.tierReport: the report-only tier assignment. */
+    tiers?: TierReport;
 }
 export interface LowerOptions {
     /** Parser/checker services owned by the load; required for npm graph analysis. */
     frontendServices?: FrontendServices | undefined;
+    /** The project's tsconfig sets `checkJs` (see isCheckedJsSourceFile). */
+    projectCheckJs?: 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;
+    /** Coverage only: module files named by --wasm (absolute). */
+    wasmFiles?: readonly string[];
     /** 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
@@ -137,6 +165,10 @@ export interface LowerOptions {
      * resolution walk and named-import link checks): the program
      * compiles to that startup crash. */
     startupCrash?: StartupCrash | null;
+    /** LoadResult.inlineRequireCycleCalls. */
+    inlineRequireCycleCalls?: ReadonlySet<ts.Node> | undefined;
+    /** LoadResult.moduleEdges. */
+    moduleEdges?: ReadonlyMap<ts.SourceFile, readonly CycleEdge[]> | undefined;
     /** LIBRARY mode's reachability roots: the profile-mapped exports of the
      * entry module. Executable builds root at the entry's top level alone
      * (an unreferenced export dead-strips); a library's exports are called from
@@ -162,6 +194,14 @@ export interface LowerOptions {
     /** The mapped entries plus relative declaration dependencies, attributed
      * to their owning external specifier. */
     externalTypeSpecifiersByFile?: ReadonlyMap<string, readonly string[]>;
+    /** `--tier` (tier-analysis.ts); "auto" when absent. */
+    tierMode?: TierMode;
+    /** Coverage only: compute the tier-assignment report (`--explain-dynamic`).
+     * `preflight` holds the import and package refusals coverage reports
+     * beside the lowering's own blockers; they request module demotions. */
+    tierReport?: {
+        preflight: readonly ScrDiagnostic[];
+    };
 }
 interface RuntimeFenceFallback {
     code: `SC${number}`;
@@ -195,38 +235,52 @@ interface RuntimeFenceClosureTarget extends Omit<RuntimeFenceFunctionTarget, "ki
 }
 /** The Lowerer's pass configuration (see lowerToIr). */
 export interface LowererMode {
+    /** Symbols whose deferred diagnostics reachable emit already flushed —
+     * the remainder must not report them a second time. */
+    alreadyFlushed?: ReadonlySet<ts.Symbol>;
+    /** LowerOptions.externalTypes, threaded through every lowering pass. */
+    externalTypes?: ReadonlyMap<string, string>;
+    /** LowerOptions.externalTypeSpecifiersByFile, shared by every pass. */
+    externalTypeSpecifiersByFile?: ReadonlyMap<string, readonly string[]>;
+    /** Program-validated ambient declaration symbols for each FFI name.
+     * Undefined in discovery's legacy call-local validation path. */
+    ffiBindingSymbols?: ReadonlyMap<string, ReadonlySet<ts.Symbol>>;
+    /** The build's outbound native FFI declarations. */
+    ffiImports?: readonly IrFfiImport[];
+    /** Statically resolved child_process.fork program roots, in stable target-id order. */
+    forkTargets?: readonly ts.SourceFile[];
     frontendServices?: FrontendServices | undefined;
+    /** The program's general stream representation (TypeMapperCtx.
+     * generalNodeStreams). lowerToIr turns it on only after a pass without
+     * it saw a stream flow that needs it (requiresGeneralNodeStreams). */
+    generalNodeStreams?: boolean;
+    /** With generalNodeStreams, the checked-dynamic stream slots
+     * (TypeMapperCtx.dynNodeStreams). lowerToIr turns it on only after a
+     * pass saw an untyped value flow into a stream slot
+     * (requiresDynNodeStreams). */
+    dynNodeStreams?: boolean;
+    /** LoadResult.inlineRequireCycleCalls. */
+    inlineRequireCycleCalls?: ReadonlySet<ts.Node> | undefined;
+    /** LowerOptions.libraryCallbacks (see there). */
+    libraryCallbacks?: boolean;
+    projectCheckJs?: boolean;
     /** Names of bodies a prior reachability 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 reachable emit 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 / named-import
      * link checks): %main opens with exactly this throw, before any
      * module init — Node refuses the whole graph before anything evaluates,
      * so nothing runs. */
     startupCrash?: StartupCrash | null;
-    /** The build's outbound native FFI declarations. */
-    ffiImports?: readonly IrFfiImport[];
-    /** LowerOptions.libraryCallbacks (see there). */
-    libraryCallbacks?: boolean;
-    /** Statically resolved child_process.fork program roots, in stable target-id order. */
-    forkTargets?: readonly ts.SourceFile[];
+    /** The build's target platform (LowerOptions.targetPlatform — lowerToIr
+     * passes it to every pass). Defaults to the host. */
+    targetPlatform?: string;
+    /** LowerOptions.tierMode, shared by every pass. */
+    tierMode?: TierMode;
     workerTargets?: readonly ts.SourceFile[];
-    /** Program-validated ambient declaration symbols for each FFI name.
-     * Undefined in discovery's legacy call-local validation path. */
-    ffiBindingSymbols?: ReadonlyMap<string, ReadonlySet<ts.Symbol>>;
-    /** LowerOptions.externalTypes, threaded through every lowering pass. */
-    externalTypes?: ReadonlyMap<string, string>;
-    /** LowerOptions.externalTypeSpecifiersByFile, shared by every pass. */
-    externalTypeSpecifiersByFile?: ReadonlyMap<string, readonly string[]>;
 }
 /** Build lowering runs as a reachability worklist over the ts.Program:
  *
@@ -295,6 +349,15 @@ export declare class Lowerer {
     readonly checker: ts.TypeChecker;
     readonly diags: ScrDiagnostic[];
     readonly fnSigsBySymbol: Map<ts.Symbol, FnSig>;
+    /** Per file: whether it assigns `exports` and `module.exports`
+     * (cjs-exports-object.ts). */
+    readonly cjsExportsAssignments: Map<ts.SourceFile, {
+        exports: boolean;
+        moduleExports: boolean;
+    }>;
+    /** Inline require() calls whose module edge closes a require cycle
+     * (LoadResult.inlineRequireCycleCalls). */
+    readonly inlineRequireCycleCalls: ReadonlySet<ts.Node>;
     /** Immutable callable aliases and compiler-generated adapters. The map
      * is symbol-keyed, so shadowing and cross-module imports keep the same
      * exact binding discipline as globals/functions. */
@@ -318,6 +381,9 @@ export declare class Lowerer {
      * NaN, which lower to plain doubles (see nan-coded-reads.ts). Settled by
      * analyzeRuntimeOptionalArrayReads before any body lowers. */
     nanCodedReads: NanCodedReads | null;
+    /** Whether any implementation source spells `versions`
+     * (programMentionsVersions in builtins/process.ts). */
+    mentionsProcessVersions: boolean | undefined;
     private stringIndexBoundsCache;
     /** Proofs that a string element read names an existing code unit. The
      * indexed-read analysis and expression lowering share one instance, so a
@@ -326,6 +392,9 @@ export declare class Lowerer {
     /** Syntactic writes indexed once per JS scope. Symbol and RHS type
      * checks remain contextual to each binding probe. */
     readonly jsBindingWritesByOwner: Map<import("../ts7/ast-node.js").AstNode, Map<string, ts.BinaryExpression[]>>;
+    /** JavaScript function declarations their own module reassigns
+     * (rebindable-functions.ts). */
+    readonly rebindableFunctions: Set<ts.FunctionDeclaration>;
     /** TRAP bindings: declarations whose initializer provably throws before
      * producing a value (its chain roots at an ambient-undefined name —
      * ambientUndefVarRootOf). Module init unwinds at the declaration, so no
@@ -383,10 +452,32 @@ export declare class Lowerer {
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings: Map<ts.Symbol, IrType> | null;
+    /** Generic lambdas lowering as erased values (lowerLambda): their own
+     * type parameters are bound to `unknown`, so lambdaSignature admits
+     * them. */
+    readonly erasingLambdas: Set<import("../ts7/ast-node.js").AstNode>;
+    /** Function expressions lowered against a fixed target signature with a
+     * tuple-typed `arguments` (typed-arguments.ts). */
+    readonly typedArgumentsLambdas: Set<import("../ts7/ast-node.js").AstNode>;
+    /** Const bindings holding a forwarded fixed tuple (`const args =
+     * arguments as any` in a typed-arguments function) → the tuple type. */
+    readonly tupleAliasSymbols: Map<ts.Symbol, IrType>;
+    /** `??` expressions whose result is the optional callback's own function
+     * type (an adapted function default); their bindings take that type. */
+    readonly nullishFuncResults: Set<import("../ts7/ast-node.js").AstNode>;
+    /** The static names of the current generic instance's name-keyed
+     * function parameters (static-function-names.ts). */
+    staticFnNames: Map<ts.Symbol, string | null> | null;
+    /** Nesting depth of erased generic bodies being lowered (erased lambdas
+     * and erased instances). */
+    erasingDepth: number;
     localClassInstantiations: {
         owner: ts.FunctionLikeDeclaration;
         name: string;
     }[];
+    /** Instance types (by checker type id) of the local classes generic
+     * factory calls return, and the per-instance class each names. */
+    readonly localClassInstanceTypes: Map<number, string>;
     /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed
      * instance body lowers: type-parameter symbol → the bound CHECKER type,
      * consulted where the mapped IrType has already widened away information
@@ -400,6 +491,25 @@ export declare class Lowerer {
      * 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;
+    /** The builtin class each binding names (`const E = EventEmitter`,
+     * `const C = zlib.Gzip`), keyed by the binding's symbol; null for
+     * bindings that name none (builtinClassAliasOf). new, instanceof,
+     * typeof, .name and === resolve at compile time. */
+    readonly builtinClassAliases: Map<ts.Symbol, BuiltinClassRef | null>;
+    /** Whether some net.Socket in this program may get an encoding: a
+     * setEncoding call whose receiver is a socket or an untyped value.
+     * Computed once on first use (null until then). */
+    socketEncodingReachable: boolean | null;
+    /** Whether some program source can define a thenable
+     * (programMayDefineThenables). Null until first asked. */
+    thenablesMayBeDefined: boolean | null;
+    /** Lambdas lowered with checked-dynamic parameters (lambdaSignature):
+     * callbacks whose arguments are wider than their contextual overload. */
+    readonly dynParamLambdas: Set<import("../ts7/ast-node.js").AstNode>;
+    /** Whether some server in this program may listen on a Unix socket: a
+     * listen call whose first argument is a string. Computed once on first
+     * use (null until then); address() answers the path only when true. */
+    unixListenReachable: boolean | 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). */
@@ -415,8 +525,13 @@ export declare class Lowerer {
      * their symbol/node keys; no module-level cache should retain a pass. */
     readonly classSymbolKeys: Map<ts.Symbol, ClassSymbolKey | null>;
     readonly registeredClassSymbols: Map<string, ts.Symbol>;
+    /** Symbol-key identities by description, in resolution order (the slot
+     * ordinals of key-table keys — symbolKeyOf). */
+    readonly symbolFieldIdentities: Map<string, ts.Symbol[]>;
     readonly httpClientFnBindings: Map<ts.Symbol, HttpClientFnBinding>;
     streamPropMutatedSyms: Set<ts.Symbol> | null;
+    /** Whether some source reads process.exitCode (processReadsExitCode). */
+    readsExitCode: boolean | null;
     requestInitPropMutatedSyms: Set<ts.Symbol> | null;
     emitterEventTable: Map<string, EventSig> | null;
     emitterComputedPatterns: ComputedEventPattern[];
@@ -445,6 +560,20 @@ export declare class Lowerer {
      * carry undefined at runtime. Identifier reads keep the union tag so
      * typeof and later boundaries observe the real value. */
     readonly runtimeOptionalGlobals: Set<IrGlobal>;
+    /** Per CommonJS file using top-level `this`: the global holding the
+     * object that stands for its original exports (lowerCjsTopLevelThis). */
+    readonly cjsExportsThis: Map<ts.SourceFile, IrGlobal>;
+    /** Inline program-module require calls whose %init the enclosing member
+     * read or member call is already sequencing (cjs-inline-require.ts). */
+    readonly inlineRequireInitDone: Set<ts.CallExpression>;
+    /** Whether lowered code writes properties onto children, and what the
+     * program's JavaScript adds to them (handle-properties.ts). */
+    writesOntoChildren: boolean;
+    childAdditions: {
+        written: ReadonlySet<string>;
+        everyName: boolean;
+        any: boolean;
+    } | null;
     /** Bindings whose unchecked string arithmetic can produce either a number
      * (NaN for an absent read) or a string. Preserve that result union at bare
      * reads instead of applying the checker-bare string narrowing adapter. */
@@ -457,7 +586,9 @@ export declare class Lowerer {
     /** A pipeline() function stage's `source` parameter: the IR type of what
      * the pipeline passes it (the previous stage as an async iterable), set
      * while the stage lowers. Parameter typing and `for await` heads read
-     * it before the checker's `AsyncIterable<T>`. */
+     * it before the checker's `AsyncIterable<T>`. A stream option callback's
+     * completion parameter declared with an any-typed `data` is pinned here
+     * too while the callback lowers (pinAnyDataCompletion). */
     readonly stageSourceTypes: Map<ts.Symbol, IrType>;
     /** Set when a match result lowers to execGroups/matchGroups, the inputs
      * of regex span folding. */
@@ -467,6 +598,10 @@ export declare class Lowerer {
      * declared optional binding to that read's bare type, so presence tests
      * on these bindings consult the stored tag instead. */
     readonly runtimeOptionalAssignedSymbols: Set<ts.Symbol>;
+    /** Generic function declarations whose body can return an indexed read
+     * that misses.
+     * Each instance's result admits undefined (generic-functions.ts). */
+    readonly runtimeOptionalGenericReturns: Set<import("../ts7/ast-node.js").AstNode>;
     /** Concise callback/lambda returns promoted by the HOF callback prepass;
      * arrows have no declaration symbol to key in fnSigsBySymbol. */
     readonly runtimeOptionalFunctionReturns: Map<import("../ts7/ast-node.js").AstNode, IrType>;
@@ -480,6 +615,8 @@ export declare class Lowerer {
     /** Record fields promoted to an undefined-armed union by an indexed-read
      * value. The key is the concrete emitted shape and field name. */
     readonly runtimeOptionalFields: Set<string>;
+    /** Bindings initialized by a Date's `toJSON()` (analyzeDateJsonResults). */
+    readonly dateJsonBindings: Set<ts.Symbol>;
     /** Record bindings whose flow class reaches storage outside the class:
      * they keep the declared layout, so an initializer from unchecked reads
      * converts once instead of the binding adopting the widened variant. */
@@ -508,11 +645,29 @@ export declare class Lowerer {
     runtimeOptionalRootOf(local: IrLocal): IrLocal;
     runtimeOptionalBindingType(node: ts.Node): IrType | null;
     runtimeOptionalBindingType(node: ts.Node, fallback: IrType): IrType;
+    /** A TypeScript object literal handed to a JavaScript checked-value
+     * parameter whose inferred type is open (`constructor({ factory, ...options
+     * } = {})` — the rest element admits any property): the literal names a
+     * property the contextual JS type does not declare, so it has no record
+     * layout there and is built as the plain object the JS side receives. */
+    private excessJsContextualProperty;
+    /** The index value of a keyed read of a record's index signature that
+     * can answer undefined for a missing key while its checker type does not
+     * admit undefined, or null. A literal key naming a declared field is a
+     * field read. */
+    optionalIndexSignatureRead(e: ts.ElementAccessExpression): IrType | null;
     runtimeOptionalIdentifierValue(node: ts.Expression): {
         value: IrExpr;
         present: IrType;
         unionId: string;
     } | null;
+    /** True when `node`'s lowered value can hold a hidden `undefined` the
+     * checker type does not admit: an unchecked element or member read, a call
+     * whose lowered return admits undefined, or a binding whose storage the
+     * optional-read analysis marked. Whether the value actually carries the
+     * undefined arm is only known once it is lowered
+     * (runtimeOptionalSourceValue); this is the syntactic precondition. */
+    isRuntimeOptionalOrigin(node: ts.Expression): boolean;
     /** Recover the original optional union when a checked single-arm helper
      * was installed before a strict property consumer could name its member.
      * Recovery covers member reads and storage roots marked by the
@@ -523,7 +678,7 @@ export declare class Lowerer {
      * value. Reuse a plain read directly or stabilize an effectful receiver
      * once, throw Node's member-read TypeError for a unit arm, and extract the
      * expected present arm otherwise. */
-    runtimeOptionalPropertyReceiver(node: ts.Expression, value: IrExpr, expected: IrType, member: string): IrExpr | null;
+    runtimeOptionalPropertyReceiver(node: ts.Expression, value: IrExpr, expected: IrType, member: string, action?: "read" | "set"): IrExpr | null;
     runtimeOptionalFieldKey(shapeId: string, field: string): string;
     isRuntimeOptionalField(shapeId: string, field: string): boolean;
     isRuntimeOptionalGlobal(global: IrGlobal): boolean;
@@ -574,10 +729,28 @@ export declare class Lowerer {
     /** Settled generic class-rest metadata requires the historical emit
      * fallback so its fence can poison the original statement atomically. */
     requiresHistoricalOrderRelower: boolean;
+    /** A general stream value (a runtime stream class instance) reached a
+     * slot the child/process stdio handles represent — NodeJS.ReadableStream,
+     * NodeJS.WritableStream, or @types/node's stream.Readable/Writable — or
+     * a stdio handle reached an 'unknown' slot. lowerToIr then lowers the
+     * program again under the general stream representation. */
+    requiresGeneralNodeStreams: boolean;
+    /** An untyped value reached a stream slot (a checked unwrap into a
+     * runtime stream class, or an untyped pipe/pipeline stage). lowerToIr
+     * then lowers the program again with checked-dynamic stream slots
+     * (dyn-streams.ts). */
+    requiresDynNodeStreams: boolean;
+    /** Receiver representations forced by the per-value stream dispatch
+     * (dyn-streams.ts): the native arm lowers a member call on the unboxed
+     * stream through the ordinary class-method path. */
+    readonly receiverTypeOverrides: Map<import("../ts7/ast-node.js").AstNode, IrType>;
     /** Helpers that snapshot shape declaration order into their bodies.
      * Reachability lowers inits before the declarations they discover, so
      * these rebuild after the worklist restores historical shape metadata. */
     readonly shapeOrderHelperFinalizers: (() => void)[];
+    /** Construction witnesses that choose each shape's enumeration order
+     * once lowering settles (key-order-witness.ts). */
+    readonly keyOrder: KeyOrderNotes;
     /** Emit-override specializations (`%C.emit:<event>` — lower-event-emitter.ts's
      * emit-overrides block): interned names, the drive-loop queue, and the
      * currently-lowering specialization's context (the super-forward
@@ -589,6 +762,9 @@ export declare class Lowerer {
     /** Generated value helpers, keyed by operation and type. Callers own
      * their key prefixes; this includes more than structural conversions. */
     readonly valueHelpers: Map<string, string>;
+    /** structuralNarrowing's assignable classes, keyed by static and
+     * narrowed class name. */
+    readonly structuralClassPeers: Map<string, readonly string[]>;
     /** Interned node:assert helpers (deep-equality comparisons keyed by
      * typeKey, throws wrappers keyed by callback type + expected class) —
      * the valueHelpers pattern with its own namespace. */
@@ -609,6 +785,16 @@ export declare class Lowerer {
     /** Method adapter names are owned by class-method-values. Looking them
      * up must not scan and retain every unrelated lifted function. */
     readonly classMethodValueHelpers: Set<string>;
+    /** Reflected class methods whose lambda is lowering right now (null
+     * until lowerLambda named it), with the closure it will produce: a
+     * method that reads itself as a value inside its own body
+     * (`o.create = K.create`) takes this closure instead of lowering the
+     * method again. */
+    readonly methodLambdasInProgress: Map<import("../ts7/ast-node.js").AstNode, {
+        fnName: string;
+        type: IrType;
+        selfReads: number;
+    } | null>;
     readonly classMethodValueSelections: Map<string, import("./class-method-values.js").ClassMethodValueSelection>;
     /** Callee names of every interned coercion helper whose CALL mints a
      * FRESH closure per evaluation (%fn.width.*, %fn.adapt.*,
@@ -635,6 +821,13 @@ export declare class Lowerer {
             kind: "func";
         };
     }>;
+    /** Accessor exports' link-time values for ES-module importers, and the
+     * per-module flag that the copy already ran (cjsAccessorSnapshotStores). */
+    readonly cjsAccessorSnapshots: Map<import("../ts7/ast-node.js").AstNode, {
+        id: string;
+        type: IrType;
+    }>;
+    readonly cjsSnapshotReady: Map<ts.SourceFile, 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. */
@@ -659,6 +852,8 @@ export declare class Lowerer {
      * so named imports, namespace reads, CommonJS bindings, and alias chains
      * all reuse one immortal zero-capture closure. */
     readonly builtinCallableValueFns: Map<string, string>;
+    /** Each builtin function-value adapter's Node name, for boxed values. */
+    readonly builtinCallableValueNames: 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
@@ -712,6 +907,10 @@ export declare class Lowerer {
     /** Named method slots observed before class collection need a callable
      * ABI and shared prototype descriptors instead of call-site specialization. */
     readonly prototypeMethodAccesses: Map<string, import("../ts7/ast-node.js").AstNode>;
+    /** Well-known symbol methods (`sym:iterator`) the program may replace
+     * through a symbol-keyed write: an instance or prototype property, or a
+     * reflection call. */
+    readonly replacedSymbolMethods: Set<string>;
     /** Typed calls through class-backed protocols, by signature; class
      * dynamic dispatch adds their native arms (class-protocol-dispatch.ts). */
     readonly protocolDispatches: Map<string, ProtocolDispatch>;
@@ -729,6 +928,9 @@ export declare class Lowerer {
      * base vtable signature is collected. Unused checked slots carry undefined. */
     readonly virtualJsMethodArity: Map<ts.MethodDeclaration, number>;
     readonly checkedVirtualJsMethods: Set<ts.MethodDeclaration>;
+    /** Overrides whose return narrows part of the base's union return; they
+     * return through the base's union ABI (overrideReturnAbi). */
+    readonly unionReturnOverrides: Set<ts.MethodDeclaration>;
     readonly checkedVirtualJsAccessors: Set<ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>;
     readonly checkedVirtualJsValueReturns: Set<ts.MethodDeclaration>;
     /** The class whose members are lowering — `super` binds lexically to it
@@ -752,6 +954,10 @@ export declare class Lowerer {
      * prepended by lowerFileInit so the bindings are live before any
      * top-level statement runs. */
     readonly jsonInitActions: Map<ts.SourceFile, IrStmt[]>;
+    /** CommonJS require() of JSON documents: the shared object per document
+     * and the calls reading it (json-require.ts). */
+    readonly jsonRequireModules: Map<string, JsonRequireModule>;
+    readonly jsonRequireCalls: Map<ts.CallExpression, JsonRequireModule>;
     /** Dynamic `import("literal")` resolutions, keyed
      * `fileName\u0000specifier` (collectDynamicImports fills it during npm
      * collection; lowerDynamicImportCall reads it per site). */
@@ -793,6 +999,12 @@ export declare class Lowerer {
     readonly workerTargets: readonly ts.SourceFile[];
     readonly workerTargetIdByPath: Map<string, number>;
     usesWorkers: boolean;
+    /** The program uses the WebAssembly API (builtins/webassembly.ts): the
+     * build translates the modules it discovers. */
+    usesWebAssembly: boolean;
+    /** The program calls WebAssembly.Module.customSections: translated
+     * modules keep their custom sections. */
+    usesWasmCustomSections: boolean;
     /** The program constructs a LifetimeRegion (lifetime-regions.ts). */
     usesLifetimeRegions: boolean;
     /** Per-directory answers of experimental-import.ts's declaration-file test. */
@@ -806,6 +1018,16 @@ export declare class Lowerer {
         key: string;
         node: ts.Node;
     }>;
+    /** Each ThreadSlots name's type arguments (thread-slots.ts). */
+    readonly threadSlotNames: Map<string, string>;
+    /** The family each `new ThreadSlots(...)` opens. */
+    readonly threadSlotFamilies: Map<ts.NewExpression, {
+        name: string;
+        key: IrType;
+        value: IrType;
+    }>;
+    /** Classes used as ThreadSlots keys: their hierarchies carry a slot word. */
+    readonly threadSlotKeys: Set<string>;
     readonly forkTargetIdByPath: Map<string, number>;
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
@@ -884,6 +1106,9 @@ export declare class Lowerer {
     deferredModuleInitializers: DeferredModuleInitializers | null;
     fnStack: FnCtx[];
     readonly liftedFns: IrFunction[];
+    /** Runtime-provided classes used as values (defineClassValueConstruct),
+     * by IR class name. */
+    readonly runtimeClassValues: Map<string, ClassInfo>;
     /** One Error-method helper belongs to this lowering session. Its cached
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision: string | null;
@@ -916,6 +1141,21 @@ export declare class Lowerer {
      * by class name (cycle-initialization.ts). */
     readonly classInitFlags: Map<string, CycleInitFlag>;
     readonly cycleInitDeclarations: Map<ts.StatementBase, CycleInitFlag[]>;
+    /** Each class's constructor return plan by class name
+     * (constructor-returns.ts); null when no return can yield an object. */
+    readonly constructorReturnPlans: Map<string, ConstructorReturnPlan | null>;
+    /** Pointer-guarded (`tdz`) module bindings declared without an
+     * initializer (`let f: T;`): an initialization flag tracks their
+     * declaration (markCycleEarlyBindings). */
+    readonly uninitializedLexicalGlobals: Map<string, {
+        name: ts.Identifier;
+        module: ts.SourceFile;
+        symbol: ts.Symbol;
+    }>;
+    /** CommonJS require declarations whose bindings code running before the
+     * require can read, and those references (require-initialization.ts). */
+    readonly requireInitFlags: Map<ts.VariableDeclaration, RequireInitFlag>;
+    readonly requireEarlyReferences: EarlyReference[];
     get ctx(): FnCtx;
     get scopes(): Map<ts.Symbol, IrLocal>[];
     /** Names of bodies a prior reachability pass reached; null lowers everything. */
@@ -939,6 +1179,16 @@ export declare class Lowerer {
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
      * and no module is built. */
     readonly remainder: boolean;
+    /** `--tier` (tier-analysis.ts). Stage S2 is report-only: both modes
+     * refuse and fence exactly as before. Stage S6 demotes the units of
+     * committed refusals in "auto" and keeps them refusals in "static-only". */
+    readonly tierMode: TierMode;
+    readonly generalNodeStreams: boolean;
+    readonly dynNodeStreams: boolean;
+    /** Functions finishModule placed in the dynamic tier (ir/tiers.ts). */
+    dynamicFunctions: DynamicFunction[];
+    /** Their IR, for coverage's dynamic statement count. */
+    dynamicBodies: IrFunction[];
     /** 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. */
@@ -966,6 +1216,9 @@ export declare class Lowerer {
     readonly targetPlatform: string;
     /** LowererMode.startupCrash — buildMain opens %main with the throw. */
     readonly startupCrash: StartupCrash | null;
+    /** The project's tsconfig sets `checkJs`. */
+    readonly projectCheckJs: boolean;
+    private readonly checkedJsFiles;
     /** Outbound native bindings by their source-level ambient name. */
     readonly ffiImports: readonly IrFfiImport[];
     readonly libraryCallbacks: boolean;
@@ -1007,18 +1260,47 @@ export declare class Lowerer {
         total: number;
         failed: number;
     }>;
+    /** Statements and field initializers already in the coverage totals, and
+     * those already counted as failed. Speculative lowering can lower one
+     * function body several times: each receiver probe of
+     * `(function () { ... }).call(this)` lowers it. A source statement counts
+     * once however many times it lowers. */
+    private readonly countedStatements;
+    private readonly failedStatements;
+    /** Adds `node` to the coverage totals unless it is already counted (the
+     * caller checks suppressStats). */
+    countStatement(node: ts.Node, file: string | undefined): void;
+    /** Counts `node` as failed unless it already is (the caller checks
+     * suppressStats). */
+    countStatementFailed(node: ts.Node, file: string | undefined): void;
     /** Bumps the per-file attribution counter (no-op unless provenance is
      * active and this is the emit/discovery lane — mirror the CALLER's
      * suppressStats guard, this method only gates remainder). */
     bumpFileStat(file: string, kind: "total" | "failed"): void;
     constructor(program: ts.Program, entry: ts.SourceFile, moduleOrder: ts.SourceFile[], mode?: LowererMode);
+    /** A JavaScript file TypeScript type-checks (`// @ts-check`, or the
+     * project's `checkJs`). Its JSDoc types are enforced like TypeScript
+     * annotations, so its classes use them as a TypeScript file would. */
+    checkedJsFile(sf: ts.SourceFile): boolean;
     registerBuiltinErrorClasses(): void;
     private classProtocols;
     classImplementedProtocol(type: ts.Type): boolean;
     /** Declared class fields may store a DYN value only when its static type
-     * names checked protocol identity or an owned runtime handle (a Worker
-     * or MessagePort); `unknown` and `any` fields stay refused. */
+     * is `unknown` or `object` (also with `null` or `undefined`, or an array
+     * of those), names checked protocol identity, is an owned runtime
+     * handle (a Worker or MessagePort, a fetch Headers/Request/Response, or
+     * a node:crypto ECDH), or is a WeakMap/WeakSet (native weak collections
+     * live in checked-dynamic storage, as locals of those types do); `any`
+     * fields stay refused. */
     classFieldStoresDyn(type: ts.Type): boolean;
+    /** A stdlib WeakMap or WeakSet, alone or with `null`/`undefined`. */
+    private weakCollectionType;
+    /** A type `handle` accepts, alone or with `null`/`undefined`. */
+    private stdlibHandleType;
+    /** `unknown`, `object`, an array of those, or a union of those with
+     * `null` and `undefined`: types whose values use checked-dynamic storage
+     * as they do in JavaScript class fields. */
+    private opaqueValueType;
     /** The nominal identity of a checker module-namespace type. Program
      * modules use their normalized absolute source name; supported builtins
      * use the lowering tables' canonical bare name. */
@@ -1027,6 +1309,8 @@ export declare class Lowerer {
     builtinErrorInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
     builtinEmitterInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
     builtinStreamInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
+    builtinClassAliasOf(symbol: ts.Symbol): BuiltinClassRef | null;
+    defineClassValueConstruct(info: ClassInfo): void;
     /** 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
@@ -1090,6 +1374,11 @@ export declare class Lowerer {
      * 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;
+    /** For an inline program `require("./c")`: the class symbol its module's
+     * kept `module.exports = <class identifier>` names, or null when the
+     * whole export is something else. Undefined when `expr` is not such a
+     * require. */
+    memberExportRequiredClass(expr: ts.Expression): ts.Symbol | null | undefined;
     /** 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
@@ -1097,6 +1386,12 @@ export declare class Lowerer {
      * (any .ts, ESM-syntax .js/.mjs) answer null and keep the ESM default
      * machinery. */
     private cjsDefaultImportDepOf;
+    /** The table module a non-identifier module reference names: an inline
+     * `require("./x")` (cjs-inline-require.ts) or tsc's unstamped
+     * `x_1.default` interop read (cjs-tsc-interop.ts). */
+    cjsModuleRefDepOf(expr: ts.Expression): ts.SourceFile | null;
+    /** The table module a CommonJS module binding identifier names. */
+    cjsModuleBindingDepOf(expr: ts.Identifier): ts.SourceFile | null;
     /** The compiled module behind a require-like namespace binding: an
      * ordinary CommonJS require declaration, a canonical createRequire
      * declaration, or an ESM default import of CommonJS. One resolver keeps
@@ -1139,6 +1434,17 @@ export declare class Lowerer {
      * calls of these names. Runs in every pass so the ids are
      * deterministic. */
     prepareModuleInits(parts: FileParts[]): void;
+    /** node:punycode's load at a require() call: the module body reports
+     * DEP0040 when it first runs, unless isInsideNodeModules() finds the
+     * requiring frame in a dependency, and process.emitWarning delivers the
+     * report on the next tick. Later loads are cache hits either way. */
+    punycodeRequireWarning(node: ts.Node): IrStmt;
+    /** node:punycode's DEP0040 for a static ES import anywhere in the module
+     * graph: Node links builtins before any module evaluates, so the report
+     * comes first, before the program can register a 'warning' listener —
+     * whichever file imports it (a dependency's ES import has no requiring
+     * frame either). Prepended to the entry's %init. */
+    punycodeLinkWarning(): IrStmt[];
     /** 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
@@ -1159,6 +1465,16 @@ export declare class Lowerer {
      * TypeScript's default indexed-access type is a useful source annotation,
      * but it is not a runtime proof; promoting only the affected slots keeps
      * the rest of the dense ABI unchanged. */
+    /** A Date's `toJSON()` answers null for an invalid date while the lib
+     * types say `string`: unannotated bindings initialized by such a call,
+     * and object-literal fields holding one, keep `string | null`. */
+    analyzeDateJsonResults(parts: FileParts[]): void;
+    /** A file-scope get-or-create read (`let e = map[k]; if (e ===
+     * undefined) ...` over an index-signature record) keeps a missing key as
+     * undefined (isGuardedRecordRead). Its pre-registered global takes the
+     * undefined arm before any body reads it; the declaration lowers its
+     * initializer as the matching absence probe. */
+    analyzeGuardedRecordReadGlobals(parts: FileParts[]): void;
     analyzeRuntimeOptionalArrayReads(parts: FileParts[]): void;
     run(): LowerResult;
     /** Final retention, pruning, and module assembly shared by ordinary emit
@@ -1225,6 +1541,21 @@ export declare class Lowerer {
     deferToRuntimeFence(diagsBefore: number, node: ts.Node, target: RuntimeFenceStatementTarget): IrStmt | null;
     deferToRuntimeFence(diagsBefore: number, node: ts.Node, target: RuntimeFenceFunctionTarget): IrFunction | null;
     deferToRuntimeFence(diagsBefore: number, node: ts.Node, target: RuntimeFenceClosureTarget): IrExpr | null;
+    /** The runtimeFence statement that throws `first`'s message (or the
+     * fallback's) at `node`. */
+    private runtimeFenceStmt;
+    /** The current length of the capture buffer (diagSink), or 0 without one:
+     * the mark capturedRuntimeFence reads the refusal from. */
+    diagSinkMark(): number;
+    /** The runtimeFence for a JavaScript statement refused while a capture
+     * buffer (diagSink) is active. The buffer's owner decides whether its
+     * diagnostics report, and some owners keep the lowered result (a
+     * successful tryLowerExpression candidate, a computed class base whose
+     * diagnostics defer to the class). Without a fence the refused statement
+     * would vanish from that result; with one it throws the refusal when it
+     * runs, exactly like the fence lowerStmts emits outside a buffer. The
+     * diagnostics stay in the buffer for its owner. Null without a buffer. */
+    capturedRuntimeFence(sinkMark: number, node: ts.Node): IrStmt | null;
     /** 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. */
@@ -1255,6 +1586,10 @@ export declare class Lowerer {
      * body lowers) type-parameter bindings threaded through. A supplied mapper
      * retains interface-view substitutions while sharing ABI normalization. */
     mapTypeOf(t: ts.Type, mapper?: (type: ts.Type) => IrType | null): IrType | null;
+    /** The runtime type of a record member slot typed `t`: an overloaded
+     * member's erased function (erasedOverloadMemberType — the type a record
+     * shape stores for it), otherwise mapTypeOf. */
+    memberSlotTypeOf(t: ts.Type): IrType | null;
     /** The one position where a contextual UNION must not be adopted over the
      * expression's own: the LEFT operand of `&&`, `||`, or `??`. Adopting a
      * contextual union is normally safe because tsc proved the value
@@ -1435,6 +1770,9 @@ export declare class Lowerer {
     recordUnionWrapHelper(source: IrType & {
         kind: "record";
     }, toId: string, loc: SrcLoc): string | null;
+    recordUnionRouteHelper(source: IrType & {
+        kind: "record";
+    }, toId: string, loc: SrcLoc): string | null;
     unionRetagHelper(fromId: string, toId: string, loc: SrcLoc, trappable?: ReadonlySet<number>): string | null;
     narrowedArmHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
     checkedNarrowCall(helper: string, value: IrExpr, type: IrType, loc: SrcLoc): IrExpr;
@@ -1466,6 +1804,10 @@ export declare class Lowerer {
     /** Lower for a known destination, then apply ordinary value coercion.
      * Fresh arrays and records use the destination layout directly. */
     lowerExprExpecting(node: ts.Expression, expected: IrType | undefined): IrExpr;
+    /** The conversion lowerExprExpecting applies to `e`, the lowered value
+     * of `node` when it is not fresh construction the destination directs
+     * (a literal, conditional, or empty collection). */
+    coerceExistingInto(node: ts.Expression, e: IrExpr, expected: IrType): IrExpr;
     /** An unannotated empty collection has no existing elements or aliases
      * that constrain its layout. An explicit type argument still wins. */
     emptyCollectionFor(node: ts.Expression, expected: IrType): IrExpr | null;
@@ -1481,6 +1823,14 @@ export declare class Lowerer {
      * declared result type of an index-signature read under
      * noUncheckedIndexedAccess. Null when the type cannot take the arm. */
     withUndefinedArmOf(t: IrType): IrType | null;
+    /** Whether a promise of `from` converts to a promise of `to` through the
+     * checked payload widening (coerceToExpected's boxed-settlement rule,
+     * which keeps the promise's identity and settlement turn). */
+    promisePayloadWidens(from: IrType & {
+        kind: "promise";
+    }, to: IrType & {
+        kind: "promise";
+    }): boolean;
     /** True when a static type converts to a dyn value (the dynFrom
      * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the checked-dynamic tree's
      * bytes kind, payload copied; stdin chunks into unknown-typed helpers),
@@ -1502,6 +1852,13 @@ export declare class Lowerer {
      * 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;
+    /** A fresh JS object literal returned into a checked-native (dyn) result,
+     * which lowers straight into that storage. */
+    private returnsLiteralIntoDyn;
+    /** The value of `return <e>` (already lowered untyped) in an async or
+     * void context: a promise flattens through the returned-promise await,
+     * everything else converts into the declared result. */
+    private asyncReturnValueOf;
     /** Whether a promise returned here resolves the function's own promise
      * by adoption (async functions; async generators await their return
      * operand instead). */
@@ -1520,6 +1877,10 @@ export declare class Lowerer {
      * 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;
+    /** `return u` of a promise-armed union (maybe-promise, or promise-or-
+     * unit) in an async function: adopt the promise arm, fulfill with the
+     * others (maybe-promise.ts). Null when the return is not that shape. */
+    maybePromiseReturn(node: ts.Expression, e: IrExpr, expected: IrType): IrStmt | null;
     private lowerReturnOf;
     maybeNarrow(expr: IrExpr, node: ts.Node): IrExpr;
     lowerUnitComparison(left: IrExpr, right: IrExpr, negated: boolean, loc: SrcLoc): IrExpr | null;
@@ -1619,6 +1980,21 @@ export declare class Lowerer {
         ordinal: number;
     }): void;
     lowerClassExpressionInfo(expr: ts.ClassLikeDeclaration): ClassInfo;
+    /** Depth of the whole-program analyses that query types across every
+     * file before reachability is known (speculativeTypeQueries). */
+    private speculativeTypeQueryDepth;
+    /** Runs a whole-program analysis whose type queries are speculative: they
+     * visit every file, reached or not, and no statement or declaration owns
+     * a refusal they trigger (collectLocalClassForType). */
+    speculativeTypeQueries(analysis: () => void): void;
+    /** Collects a function-local class because a type query named its
+     * instance type. Collection and body lowering own a refusal of that
+     * class: the poison reaches the declaration or statement that asked, as
+     * before. A speculative whole-program analysis owns none, so there the
+     * refusal stays reported (the build fails with it, as it did where such
+     * an analysis already caught the poison) and the class is unmappable for
+     * the query instead of the poison escaping the compiler. */
+    collectLocalClassForType(decl: ts.ClassLikeDeclaration): boolean;
     lowerClassExpression(expr: ts.ClassLikeDeclaration): IrExpr;
     findMethodOn(info: ClassInfo | null, name: string): {
         declarer: ClassInfo;
@@ -1630,6 +2006,9 @@ export declare class Lowerer {
             gen?: NonNullable<IrFunction["generator"]>;
         };
     } | null;
+    /** A class whose root is the runtime's %Error (builtin errors and their
+     * program subclasses). */
+    isErrorRootedClass(className: string): boolean;
     isSubclassOf(sub: string, sup: string): boolean;
     inHierarchy(info: ClassInfo): boolean;
     overrideBelow(info: ClassInfo, name: string): boolean;
@@ -1732,6 +2111,9 @@ export declare class Lowerer {
     collectGlobals(sf: ts.SourceFile, topStmts: ts.Statement[]): void;
     lowerFileInit(sf: ts.SourceFile, stmts: ts.Statement[], name: string): IrFunction;
     lowerDefaultExport(stmt: ts.ExportAssignment): IrStmt | null;
+    /** Statements %main runs before any module initializer: runtime
+     * registrations the lowering passes add. */
+    readonly mainPrelude: IrStmt[];
     buildMain(): IrFunction;
     declareLocal(nameNode: ts.Node, name: string, type: IrType, mutable: boolean): IrLocal;
     /** A never-returning call in a value position of type `expected`: the
@@ -1743,6 +2125,21 @@ export declare class Lowerer {
      * 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;
+    /** The body binding of a fixed-tuple rest parameter: one native slot per
+     * position (the flattened ABI), rebuilt into the tuple the source names.
+     * The empty tuple rides the empty-array representation. */
+    declareRestTupleParam(decl: ts.ParameterDeclaration, nameNode: ts.Identifier, elemShapes: readonly ParamShape[], params: IrParam[], prologue: IrStmt[]): void;
+    /** `value as never` flowing into a typed slot: `never` is assignable to
+     * every type, so the assertion promises the slot's type. A dynamic value
+     * takes the checked extraction to it, as `value as T` would. Null for
+     * every other form, and for numeric, dynamic and union slots, which
+     * keep the existing lowering. */
+    private neverAssertionInto;
+    /** The tuple record of a forwarded-only rest tuple's native slots. */
+    private forwardedSlotsTuple;
+    /** A fresh tuple holding the given positional slots, typed `tupleType`
+     * (a tuple record, or the empty-array form of `[]`). */
+    tupleOfSlots(slots: readonly IrLocal[], tupleType: IrType, blame: ts.Node, loc: SrcLoc): IrExpr;
     /** 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`
@@ -1773,7 +2170,7 @@ export declare class Lowerer {
     /** 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;
+    resolveThis(blame?: ts.Node): IrLocal | null;
     peekLocal(ident: ts.Identifier): IrLocal | null;
     resolveKey(symbol: ts.Symbol | undefined, blame?: ts.Node): IrLocal | null;
     isSelfReference(ident: ts.Identifier): boolean;
@@ -1990,7 +2387,7 @@ export declare class Lowerer {
     }, loc: SrcLoc): IrExpr | null;
     lowerSpawnSyncCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
     lowerSpawnCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-    lowerExecFileCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+    lowerExecFileCall(expr: ts.CallExpression, loc: SrcLoc, shell?: boolean): IrExpr;
     lowerExecSyncCall(expr: ts.CallExpression, shell: boolean, loc: SrcLoc): IrExpr;
     envToPairsHelper(shapeId: string, loc: SrcLoc): string | null;
     lowerJsonMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;