@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/lowering/lowerer.js

@@ -1,18 +1,36 @@
+import { onlyForwarded } from "./typed-arguments.js";
+import { needsGeneralNodeStreams, noteUntypedStreamFlow, stdioIntoGeneralStream, } from "./general-streams.js";
+import { extendAssertedRecordMembers } from "./assertion-members.js";
+import { jsDynamicDeclarations } from "./js-dynamic-objects.js";
+import { isJsSourceFileName } from "../tsc-codes.js";
+import { builtinClassKind, builtinClassValue, builtinMemberClassKind, } from "./builtins/builtin-class-dyn.js";
 import { lifetimeRegionType, lowerLifetimeRegionCall, lowerLifetimeRegionNew, } from "./lifetime-regions.js";
 import { internTableType, lowerInternTableCall, lowerInternTableNew } from "./intern-tables.js";
+import { lowerThreadSlotsCall, lowerThreadSlotsNew, threadSlotsType } from "./thread-slots.js";
 import { isExperimentalDeclarationFile } from "../experimental-import.js";
 import { checkCycleBindingAccesses, refuseUncheckedCycleReads, } from "./cycle-initialization.js";
+import { isJsonRequireDecl } from "./json-require.js";
+import { checkRequireBindingAccesses, } from "./require-initialization.js";
 import { identityPreservingWidening } from "./coercions/identity.js";
 import { scanDivergences } from "./divergences.js";
+import { applyKeyOrderWitnesses, KeyOrderNotes } from "./key-order-witness.js";
 import { checkedClassAssertion } from "./class-assertions.js";
 import { narrowStoredClassValue, narrowGenericClassValue } from "./class-unions.js";
-import { isOptionalProcessStreamProperty } from "./builtins/process.js";
+import { isOptionalProcessStreamProperty, isOptionalProcessVersionsRead, } from "./builtins/process.js";
 import { isSettledIteratorValueRead } from "./lower-generators.js";
+import { isRebindableFunctionSymbol } from "./rebindable-functions.js";
 import { concreteCollectionNarrow } from "./collection-narrowing.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
 import { fenceStaticBlobMember, lowerBlobNew, lowerStaticBlobCall } from "./builtins/blob.js";
+import { lowerWebAssemblyCall, lowerWebAssemblyNew, refuseWebAssemblyUse, } from "./builtins/webassembly.js";
+import { discoverWasmModules } from "../../wasm/discover.js";
+import { encodeBase64 } from "../../wasm/base64.js";
+import { resolveRequireRuntime } from "../runtime-resolve.js";
 import { lowerKeyObjectCall } from "./builtins/key-object.js";
+import { isEcdhType, lowerEcdhCall } from "./builtins/ecdh.js";
+import { fenceWebCryptoMember, lowerWebCryptoCall } from "./builtins/webcrypto.js";
 import { hashStreamOf } from "./builtins/hash-stream.js";
+import { lowerNetAddressCall, lowerNetAddressNew } from "./builtins/net-address.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
 import { iteratorSlotAdapter } from "./iterator-adapters.js";
 import { lowerBuiltinCall } from "./builtin-calls.js";
@@ -20,7 +38,7 @@ import { CoercionState } from "./coercions/state.js";
 import { widthLiftPlan, unitOnlyElem, recordWidthPlan, describeRecordWidthBlocker, objToRecordPlan, recordToClassPlan, } from "./coercions/structural-plans.js";
 import { widthCoerce, applyWidthLift, unionRecordWidthHelper, recordWidthHelper, tupleArrayWidthHelper, emptyArrayLiftHelper, arrayWidthHelper, objRecordWidthHelper, recordClassWidthHelper, classStaticsProjection, } from "./coercions/structural.js";
 import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceAdapter, spawnResFnAdapterPlan, spawnResFnAdapter, } from "./coercions/function-adapters.js";
-import { unionRetagMappable, narrowedRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, } from "./coercions/unions.js";
+import { unionRetagMappable, narrowedRetagHelper, uninhabitedArmRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionRouteHelper, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, } from "./coercions/unions.js";
 import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
 import { devirtualizeVirtualCalls } from "./devirtualize.js";
 import { foldRegexSpanReads } from "./regex-span-reads.js";
@@ -42,11 +60,18 @@ import { InternalCompilerError } from "../../errors.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
 import {} from "./class-protocol-dispatch.js";
 import { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-dispatch.js";
+import { guardClassAttributeWrites } from "./class-attributes.js";
+import { applyHandleProperties } from "./handle-properties.js";
 import { ClassProtocols } from "./class-protocols.js";
 import { earlyReadVarSymbols } from "./var-hoisting.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
+import { assignLegacyTiers } from "../../ir/tiers.js";
+import { promoteJsvals } from "../../ir/jsval.js";
+import { analyzeTiers, dynamicStatementCount, } from "../tier-analysis.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import { finalizeClassMethodValues } from "./class-method-values.js";
+import { finalizePrivateBrands } from "./private-brands.js";
+import { tableKeyFieldType } from "./symbol-fields.js";
 export { newFnCtx } from "./function-context.js";
 /* AST + checker → IR.
  *
@@ -66,22 +91,28 @@ import { resolve } from "node:path";
 import { bindingSource } from "../binding-source.js";
 import { tsgoPath } from "../dts-paths.js";
 import * as ts from "../ts7/adapter.js";
+import { isBundledShimForwarder } from "../package-shims.js";
+import { erasedTypeOnlyImport } from "../type-only-imports.js";
 import { literalValues } from "../literal-values.js";
 import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
 import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, unsupportedNativeApiDiag, unsupportedPackageValueDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
-import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
-import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
+import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCheckedJsSourceFile, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, erasedOverloadMemberType, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isOverloadedCallableMemberType, isUnitOnlyTsType, isWorkerHandleType, isFetchHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
 import { builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
+import { builtinClassAliasOf, runtimeClassValueOfType, } from "./builtins/class-values.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules, appendForkModules, appendWorkerModules, } from "./lower-modules.js";
-import { prepareCjsModuleGraph } from "./lower-node-module.js";
+import { prepareCjsModuleGraph, usesCjsTopLevelThis } from "./lower-node-module.js";
+import { cjsNamespaceModule, cjsWholeExportValueOf, inlineNamespaceRequireOf, inlineProgramRequireOf, } from "./cjs-inline-require.js";
+import { tscInteropModuleOf } from "./cjs-tsc-interop.js";
+import { usesCjsExportsIdentity } from "./cjs-exports-object.js";
 import { registerBuiltinEventTargetClasses } from "./lower-event-target.js";
-import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorConstructorArgs, lowerNew, accessorCall, } from "./lower-classes.js";
+import { registerBuiltinErrorClasses, defineClassValueConstruct, runtimeClassConstructs, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorConstructorArgs, lowerNew, accessorCall, } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType, } from "./lower-mixins.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { funcTypeFromParamShapes, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, requireExactArityValue, collectSignature, collectSignatureInner, lambdaSignature, } from "./call-signatures.js";
-import { implicitAnyParamSymbolsOf, implicitMonoFile, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, } from "./generic-functions.js";
+import { implicitAnyParamSymbolsOf, implicitLocalFnNodeOf, implicitMonoFile, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, genericLocalClassBinding, } from "./generic-functions.js";
 import { bindingNeverReassigned } from "./binding-analysis.js";
 import { bodyReadsArguments } from "../arguments-usage.js";
 import { completeArgs, wrappedUndefined, undefinedArgFor } from "./call-arguments.js";
@@ -96,7 +127,7 @@ import { lowerEnvToPairsHelper } from "./containers/indexed-objects.js";
 import { lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew } from "./containers/bytes.js";
 import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string-and-regexp.js";
 import { lowerEmitOverrideSpec, } from "./lower-event-emitter.js";
-import { builtinImportOf, createRequireProgramModuleOf, createRequireSpecOf, fencedBuiltinImportOf, } from "./builtins/module-bindings.js";
+import { builtinImportOf, createRequireProgramModuleOf, createRequireSpecOf, fencedBuiltinImportOf, esmImportBindingKind, } from "./builtins/module-bindings.js";
 import { stripTypeCasts } from "./builtins/arguments.js";
 import { lowerBuiltinModuleCall } from "./builtins/module-calls.js";
 import { lowerTimersPromisesSetInterval, lowerTimeoutMethodCall } from "./builtins/timers.js";
@@ -115,13 +146,14 @@ import { lowerExecFileAsyncCall } from "./builtins/child-process-async.js";
 import { lowerStringDecoderMethodCall, lowerTextCodecCall } from "./builtins/text-codecs.js";
 import { lowerReadlineMethodCall } from "./builtins/readline.js";
 import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, lowerAsyncLocalStorageMethodCall, lowerTracingChannelMethodCall, lowerTracingChannelProperty, } from "./builtins/async-context.js";
+import { lowerDisposableStackNew } from "./builtins/disposable-stack.js";
 import { lowerErrorCodeProperty } from "./builtins/errors.js";
 import { lowerProcessProperty, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerProcessStreamProperty, } from "./builtins/process.js";
 import { consoleCallMember, consoleMethodMember, isConsoleLog, } from "./builtins/console.js";
 import { lowerConsoleNew } from "./lower-console.js";
 import { lowerNumberStaticCall, lowerNumberStaticProperty } from "./builtins/numbers.js";
-import { lowerDateCall } from "./builtins/dates.js";
-import { lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, } from "./builtins/constants.js";
+import { dateJsonType, isDateJsonSource, lowerDateCall } from "./builtins/dates.js";
+import { fsConstantMemberRead, fsConstantsObject, lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, } from "./builtins/constants.js";
 import { lowerStringStaticCall, lowerStringLastIndexOfCall } from "./builtins/strings.js";
 import { lowerPromiseStaticCall } from "./builtins/promises.js";
 import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, lowerLiveWebValue, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
@@ -132,14 +164,15 @@ import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js"
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerSystemErrorMapValue } from "./lower-system-errors.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr, } from "./lower-comptime.js";
-import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, } from "./lower-stmts.js";
-import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, } from "./lower-exprs.js";
+import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, matchGroupsPatternSource, isGuardedRecordRead, } from "./lower-stmts.js";
+import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, matchCallbackParamGroupsOf, } from "./lower-exprs.js";
 import { finishOptionalChain, isOptionalChainTail, lowerOptionalChain, } from "./expressions/optional-chains.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, } from "./expressions/object-literals.js";
 import { lowerRecordFieldCall, lowerObjectMethodCall } from "./lower-calls.js";
 import { fenceCrossBlockNsRef, nsPathPrefix } from "./lower-namespaces.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { lowerTernary } from "./lower-exprs.js";
+import { maybePromiseReturnStmt, maybePromiseUnionOf, promiseArmedUnionOf, } from "./maybe-promise.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 const ENTRY_NAME = "%main";
@@ -160,7 +193,7 @@ export function boundIdentifiersOf(name) {
     if (ts.isIdentifier(name))
         return [name];
     const out = [];
-    for (const el of name.elements) {
+    for (const el of name.elements.nodes) {
         // Elisions: OmittedExpression in 5.9.3, a NAMELESS BindingElement in 7
         // (the parity battery's pinned finding 2) — both spell "no binding".
         if (ts.isOmittedExpression(el) || el.name === undefined)
@@ -177,7 +210,7 @@ export function countBodyStatements(root) {
     let n = 0;
     const visit = (node) => {
         if (ts.isBlock(node) || ts.isCaseClause(node) || ts.isDefaultClause(node)) {
-            n += node.statements.length;
+            n += node.statements.nodes.length;
         }
         else if ((ts.isIfStatement(node) ||
             ts.isForStatement(node) ||
@@ -269,11 +302,15 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         cycleKeys.add(key);
         extraModuleCycleDiags.push(unsupportedDiag("SC1016", { file: entry.fileName, start: 0, end: 0 }, `circular imports (${cycle}; ${reason})`));
     };
+    // Inline require() calls closing a cycle inside the appended subgraphs
+    // join preflight's set (the same run-time refusal by name).
+    const inlineRequireCycleCalls = new Set(options.inlineRequireCycleCalls ?? []);
+    const graph = { edges: options.moduleEdges, inlineCycleCalls: inlineRequireCycleCalls };
     for (let pass = 0; pass < 32; pass++) {
         const before = moduleOrder.length;
-        appendDynamicImportModules(program, moduleOrder, onExtraCycle);
-        appendForkModules(program, moduleOrder, forkTargets, onExtraCycle);
-        appendWorkerModules(program, moduleOrder, workerTargets, onExtraCycle);
+        appendDynamicImportModules(program, moduleOrder, onExtraCycle, graph);
+        appendForkModules(program, moduleOrder, forkTargets, onExtraCycle, graph);
+        appendWorkerModules(program, moduleOrder, workerTargets, onExtraCycle, graph);
         if (moduleOrder.length === before)
             break;
         if (pass === 31)
@@ -283,16 +320,20 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const libraryCallbacks = options.libraryCallbacks ?? false;
     const externalTypes = options.externalTypes ?? new Map();
     const externalTypeSpecifiersByFile = options.externalTypeSpecifiersByFile ?? directExternalTypeSpecifiersByFile(externalTypes);
+    const tierMode = options.tierMode ?? "auto";
     const validation = new Lowerer(program, entry, moduleOrder, {
         frontendServices: options.frontendServices,
+        projectCheckJs: options.projectCheckJs ?? false,
         targetPlatform,
         startupCrash,
+        inlineRequireCycleCalls,
         ffiImports,
         libraryCallbacks,
         forkTargets,
         workerTargets,
         externalTypes,
         externalTypeSpecifiersByFile,
+        tierMode,
     });
     const ffiValidation = validateFfiImports(validation);
     timing("ffi-validate");
@@ -305,14 +346,17 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         ? validation
         : new Lowerer(program, entry, moduleOrder, {
             frontendServices: options.frontendServices,
+            projectCheckJs: options.projectCheckJs ?? false,
             targetPlatform,
             startupCrash,
+            inlineRequireCycleCalls,
             ffiImports,
             libraryCallbacks,
             forkTargets,
             workerTargets,
             externalTypes,
             externalTypeSpecifiersByFile,
+            tierMode,
             ffiBindingSymbols: ffiValidation.symbolsByName,
         });
     for (const d of extraModuleCycleDiags)
@@ -320,10 +364,55 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     for (const d of ffiValidation.diagnostics)
         reachableEmit.pushDiag(d);
     const emitted = reachableEmit.emitReachable(options.libRoots);
-    const { reachable } = emitted;
+    let { reachable } = emitted;
     let result = emitted.result;
     let resultLowerer = reachableEmit;
     timing("reachable-emit", { reachable: reachable.size });
+    // The general stream representation (TypeMapperCtx.generalNodeStreams)
+    // is a per-program decision: only a program whose reachable code moved
+    // a general stream into a stdio-represented stream slot lowers again
+    // with it. Every other program keeps the single pass above unchanged.
+    const generalNodeStreams = reachableEmit.requiresGeneralNodeStreams;
+    // Checked-dynamic stream slots (dyn-streams.ts) are a further per-program
+    // decision under the general representation: only a program that moves an
+    // untyped value into a stream slot lowers again with them.
+    let dynNodeStreams = reachableEmit.requiresDynNodeStreams;
+    const streamPass = (dyn) => {
+        const general = new Lowerer(program, entry, moduleOrder, {
+            frontendServices: options.frontendServices,
+            projectCheckJs: options.projectCheckJs ?? false,
+            targetPlatform,
+            startupCrash,
+            inlineRequireCycleCalls,
+            ffiImports,
+            libraryCallbacks,
+            forkTargets,
+            workerTargets,
+            externalTypes,
+            externalTypeSpecifiersByFile,
+            tierMode,
+            ffiBindingSymbols: ffiValidation.symbolsByName,
+            generalNodeStreams: true,
+            ...(dyn ? { dynNodeStreams: true } : {}),
+        });
+        for (const d of extraModuleCycleDiags)
+            general.pushDiag(d);
+        for (const d of ffiValidation.diagnostics)
+            general.pushDiag(d);
+        const generalEmitted = general.emitReachable(options.libRoots);
+        reachable = generalEmitted.reachable;
+        result = generalEmitted.result;
+        resultLowerer = general;
+        timing(dyn ? "dyn-streams-relower" : "general-streams-relower", { reachable: reachable.size });
+        return general;
+    };
+    if (generalNodeStreams) {
+        const general = streamPass(dynNodeStreams);
+        if (!dynNodeStreams && general.requiresDynNodeStreams) {
+            dynNodeStreams = true;
+            streamPass(true);
+        }
+    }
     // A generic class-rest support decision can depend on record metadata
     // whose historical owner is discovered only while retained bodies lower.
     // If the settled answer is a fence, rerun the ordinary reachable emit so
@@ -331,12 +420,16 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     // declarators stay unvisited, bindings block, cascades and stats match the
     // historical compiler. This is a rare compatibility fallback; programs
     // without such a settled fence retain checker-backed IR exactly once.
-    if (reachableEmit.requiresHistoricalOrderRelower) {
+    if (resultLowerer.requiresHistoricalOrderRelower) {
         const emit = new Lowerer(program, entry, moduleOrder, {
             frontendServices: options.frontendServices,
+            projectCheckJs: options.projectCheckJs ?? false,
+            ...(generalNodeStreams ? { generalNodeStreams: true } : {}),
+            ...(dynNodeStreams ? { dynNodeStreams: true } : {}),
             reachable,
             targetPlatform,
             startupCrash,
+            inlineRequireCycleCalls,
             ffiImports,
             libraryCallbacks,
             forkTargets,
@@ -344,6 +437,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
             ffiBindingSymbols: ffiValidation.symbolsByName,
             externalTypes,
             externalTypeSpecifiersByFile,
+            tierMode,
         });
         for (const d of extraModuleCycleDiags)
             emit.pushDiag(d);
@@ -392,13 +486,45 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         };
     else if (contracts.count > 0)
         result = { ...result, contracts };
+    const discoverModules = (onModule) => discoverWasmModules({
+        files: moduleOrder.includes(entry) ? moduleOrder : [...moduleOrder, entry],
+        entry: entry.fileName,
+        configured: options.wasmFiles ?? [],
+        resolveRequest: (fromFile, specifier) => {
+            const resolved = resolveRequireRuntime(fromFile, specifier, targetPlatform, undefined, options.frontendServices);
+            return resolved.ok ? resolved.value : null;
+        },
+        ...(onModule === undefined ? {} : { onModule }),
+    });
+    // A program that uses the WebAssembly API carries every module the build
+    // can see and translate (wasm/translate.ts); the rest fail at run time
+    // with the CompileError for untranslated bytes.
+    if (result.module !== null && resultLowerer.usesWebAssembly) {
+        const bytesByHash = new Map();
+        const reports = discoverModules((sha256, bytes) => bytesByHash.set(sha256, bytes));
+        const wasmModules = [];
+        for (const report of reports) {
+            const bytes = bytesByHash.get(report.sha256);
+            if (report.status !== "valid" || bytes === undefined)
+                continue;
+            wasmModules.push({ sha256: report.sha256, bytes: encodeBase64(bytes) });
+        }
+        result.module.wasmModules = wasmModules;
+        if (resultLowerer.usesWasmCustomSections)
+            result.module.wasmCustomSections = true;
+        timing("wasm-discovery", { modules: wasmModules.length });
+    }
     if (options.coverage !== true)
         return result;
-    const remainder = new Lowerer(program, entry, moduleOrder, {
+    const remainderPass = (general, dyn = dynNodeStreams) => new Lowerer(program, entry, moduleOrder, {
         frontendServices: options.frontendServices,
+        projectCheckJs: options.projectCheckJs ?? false,
+        ...(general ? { generalNodeStreams: true } : {}),
+        ...(general && dyn ? { dynNodeStreams: true } : {}),
         reachable,
         remainder: true,
         alreadyFlushed: resultLowerer.flushedSymbols,
+        inlineRequireCycleCalls,
         targetPlatform,
         ffiImports,
         libraryCallbacks,
@@ -407,19 +533,58 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         ffiBindingSymbols: ffiValidation.symbolsByName,
         externalTypes,
         externalTypeSpecifiersByFile,
+        tierMode,
     });
-    const rem = remainder.run();
+    let remainder = remainderPass(generalNodeStreams);
+    let rem = remainder.run();
+    // Unreached code reports what it would compile to once reached: a
+    // stream flow there that needs the general representation lowers the
+    // remainder again with it, as reachable emit would.
+    if (!generalNodeStreams && remainder.requiresGeneralNodeStreams) {
+        remainder = remainderPass(true, remainder.requiresDynNodeStreams);
+        rem = remainder.run();
+    }
+    if (!dynNodeStreams && remainder.generalNodeStreams && remainder.requiresDynNodeStreams) {
+        remainder = remainderPass(true, true);
+        rem = remainder.run();
+    }
+    timing("coverage-remainder");
+    // Tiers (tier-analysis.ts): reached statements in dynamic-tier functions,
+    // and with tierReport the report-only demotion analysis.
+    const dynamicFunctions = resultLowerer.dynamicBodies;
+    const tiers = options.tierReport === undefined
+        ? undefined
+        : analyzeTiers(program, {
+            mode: tierMode,
+            dynamicFunctions,
+            reached: [...options.tierReport.preflight, ...result.diagnostics],
+            deferred: result.runtimeFences,
+            unreached: [...rem.diagnostics, ...rem.runtimeFences],
+        });
+    // A dynamic function's own statements can include ones that failed.
+    const statementsDynamic = Math.min(tiers?.statementsDynamic ?? dynamicStatementCount(program, dynamicFunctions), result.stats.statementsTotal - result.stats.statementsFailed);
+    if (tiers !== undefined)
+        tiers.statementsDynamic = statementsDynamic;
+    timing("tier-analysis", { dynamic: dynamicFunctions.length });
     // Unreached JS statements whose fences deferred to runtime count as
     // failed statements in the remainder's stats, so their diagnostics must
     // travel with them: a failed statement is never left unexplained.
-    return {
+    const covered = {
         ...result,
+        stats: { ...result.stats, statementsDynamic },
         unreached: {
             diagnostics: rem.diagnostics,
             stats: rem.stats,
             ...(rem.runtimeFences.length > 0 ? { runtimeFences: rem.runtimeFences } : {}),
         },
     };
+    if (tiers !== undefined)
+        covered.tiers = tiers;
+    const wasmModules = discoverModules();
+    timing("wasm-discovery", { modules: wasmModules.length });
+    if (wasmModules.length > 0)
+        covered.wasmModules = wasmModules;
+    return covered;
 }
 /** The native namespace type produced by a literal static import() of a
  * compiled program module or supported Node builtin. This syntax-level
@@ -443,7 +608,7 @@ export function staticImportNamespaceType(lowerer, expr) {
     }
     if (!ts.isCallExpression(e) || e.expression.kind !== ts.SyntaxKind.ImportKeyword)
         return null;
-    const arg = e.arguments[0];
+    const arg = e.arguments.nodes[0];
     if (!arg || !ts.isStringLiteralLike(arg))
         return null;
     const builtin = canonicalBuiltinModule(arg.text);
@@ -451,9 +616,7 @@ export function staticImportNamespaceType(lowerer, expr) {
     if (moduleId === null) {
         const symbol = lowerer.checker.getSymbolAtLocation(arg);
         const source = symbol &&
-            lowerer.checker
-                .declarationsOf(symbol)
-                .find((decl) => ts.isSourceFile(decl) && !decl.isDeclarationFile);
+            symbol.declarations.find((decl) => ts.isSourceFile(decl) && !decl.isDeclarationFile);
         if (source &&
             !source.fileName.endsWith(".cts") &&
             !isCjsJsFile(source, lowerer.program) &&
@@ -487,7 +650,7 @@ export function uncheckedOverloadHandleCall(_lowerer, _expr) {
  * `never` at the ROOT stays out (`for (const v of [])`'s loop var — the
  * dead read the f64 mapping is FOR). */
 export function neverTaintedJsType(lowerer, node, t) {
-    if (!isJsSourceFile(node.getSourceFile()))
+    if (!isJsSourceFile(ts.getSourceFileOfNode(node)))
         return false;
     const walk = (x, depth) => {
         if (depth === 0)
@@ -514,7 +677,7 @@ export function ladderFenceExpr(lowerer, surface, node, hint) {
     const loc = locOf(node);
     const d = noLoweringDiag(surface, loc, hint);
     lowerer.runtimeFences.push(d);
-    const sf = node.getSourceFile();
+    const sf = ts.getSourceFileOfNode(node);
     const pos = ts.getLineAndCharacterOfPosition(sf, loc.start);
     return {
         kind: "strLit",
@@ -526,7 +689,7 @@ export function ladderFenceExpr(lowerer, surface, node, hint) {
 export function dynFallbackType(lowerer, node, t) {
     if (t.flags & ts.TypeFlags.Void)
         return null;
-    if (!isJsSourceFile(node.getSourceFile())) {
+    if (!isJsSourceFile(ts.getSourceFileOfNode(node))) {
         if (t.flags & ts.TypeFlags.Any)
             return DYN;
         const symbol = t.getSymbol();
@@ -539,14 +702,15 @@ export function dynFallbackType(lowerer, node, t) {
             ((lowerer.checker.getTypeArguments(x)[0]?.flags ?? 0) &
                 ts.TypeFlags.Any) !==
                 0;
-        if (symbol?.name === "Promise" &&
+        if (symbol !== undefined &&
+            ts.symbolName(symbol) === "Promise" &&
             args[0] &&
             (args[0].flags & ts.TypeFlags.Any || anyArray(args[0])))
-            return symbol.name === "Promise" && anyArray(args[0])
+            return ts.symbolName(symbol) === "Promise" && anyArray(args[0])
                 ? { kind: "promise", inner: DYN }
                 : jsFallbackPromiseType(lowerer, t);
         if (symbol &&
-            ["Generator", "AsyncGenerator", "IterableIterator"].includes(symbol.name) &&
+            ["Generator", "AsyncGenerator", "IterableIterator"].includes(ts.symbolName(symbol)) &&
             args.some((arg) => arg.flags & ts.TypeFlags.Any))
             return jsFallbackGeneratorType(lowerer, t);
         if (lowerer.checker.isArrayType(t) &&
@@ -566,19 +730,23 @@ export function dynFallbackType(lowerer, node, t) {
     if (generator)
         return generator;
     const symbol = t.getSymbol();
-    if ((symbol?.name === "Map" || symbol?.name === "ReadonlyMap") &&
+    if (((symbol !== undefined && ts.symbolName(symbol) === "Map") ||
+        (symbol !== undefined && ts.symbolName(symbol) === "ReadonlyMap")) &&
         lowerer.isStdlibSymbol(symbol)) {
         const args = lowerer.checker.getTypeArguments(t);
         if (args.length === 2) {
             const key = lowerer.mapTypeOf(args[0]);
             const value = lowerer.mapTypeOf(args[1]);
+            // Inferred JS function types keep the checked-dynamic slot (their
+            // closures carry JS arity, not a typed closure ABI).
             return {
                 kind: "map",
                 key: key &&
+                    key.kind !== "func" &&
                     isSupportedMapKey(key, key.kind === "union" ? lowerer.unions.get(key.unionId)?.arms : undefined)
                     ? key
                     : DYN,
-                value: value && isSupportedMapValue(value) ? value : DYN,
+                value: value && value.kind !== "func" && isSupportedMapValue(value) ? value : DYN,
             };
         }
     }
@@ -647,7 +815,9 @@ export function dynFallbackType(lowerer, node, t) {
  * has no fixed shape. The settled value crosses the checked native boundary. */
 function jsFallbackPromiseType(lowerer, t) {
     const symbol = t.getSymbol();
-    if (symbol?.name !== "Promise" || !lowerer.isStdlibSymbol(symbol))
+    if (symbol === undefined ||
+        ts.symbolName(symbol) !== "Promise" ||
+        !lowerer.isStdlibSymbol(symbol))
         return null;
     const inner = lowerer.checker.getTypeArguments(t)[0];
     return inner ? { kind: "promise", inner: lowerer.mapTypeOf(inner) ?? DYN } : null;
@@ -657,14 +827,14 @@ function jsFallbackPromiseType(lowerer, t) {
 function jsFallbackGeneratorType(lowerer, t) {
     const symbol = t.getSymbol();
     if (!symbol ||
-        !["Generator", "AsyncGenerator", "IterableIterator"].includes(symbol.name) ||
+        !["Generator", "AsyncGenerator", "IterableIterator"].includes(ts.symbolName(symbol)) ||
         !lowerer.isStdlibSymbol(symbol))
         return null;
     const [yielded, returned, resumed] = lowerer.checker.getTypeArguments(t);
     const unit = ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never;
     return {
         kind: "generator",
-        ...(symbol.name === "AsyncGenerator" ? { async: true } : {}),
+        ...(ts.symbolName(symbol) === "AsyncGenerator" ? { async: true } : {}),
         yieldT: yielded && yielded.flags & ts.TypeFlags.Never ? VOID : DYN,
         retT: !returned || returned.flags & unit ? VOID : DYN,
         nextT: !resumed || resumed.flags & unit ? UNDEFINED_T : DYN,
@@ -683,7 +853,7 @@ function jsFallbackFunctionType(lowerer, node, t) {
         // slot. JS inference reports the body type (`boolean` for
         // `enabled = true`) rather than that call-site type, so recover the
         // syntactic optionality from the parameter declaration.
-        const decl = lowerer.checker.valueDeclarationOf(p);
+        const decl = p.valueDeclaration;
         mapped = jsOpenObjectType(decl, mapped, lowerer.shapes, lowerer.unions);
         const optional = decl !== undefined &&
             ts.isParameter(decl) &&
@@ -694,9 +864,9 @@ function jsFallbackFunctionType(lowerer, node, t) {
         return mapped;
     });
     const retT = lowerer.checker.getReturnTypeOfSignature(sig);
-    const sigDecl = lowerer.checker.signatureDeclaration(sig);
+    const sigDecl = sig.declaration;
     const jsUnitReturn = sigDecl !== undefined &&
-        isJsSourceFile(sigDecl.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(sigDecl)) &&
         (retT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
     const ret = jsUnitReturn
         ? DYN
@@ -720,20 +890,21 @@ function jsArgumentsFunctionType(lowerer, t) {
         lowerer.checker.getConstructSignatures(t).length !== 0 ||
         lowerer.checker.getPropertiesOfType(t).length !== 0)
         return null;
-    const decl = lowerer.checker.signatureDeclaration(sigs[0]);
+    const decl = sigs[0].declaration;
     if (decl === undefined ||
         !(ts.isFunctionDeclaration(decl) ||
             ts.isFunctionExpression(decl) ||
             ts.isArrowFunction(decl)) ||
-        !isJsSourceFile(decl.getSourceFile()))
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)))
         return null;
-    const hasRest = decl.parameters.some((p) => p.dotDotDotToken !== undefined);
+    const hasRest = decl.parameters.nodes.some((p) => p.dotDotDotToken !== undefined);
     if (!hasRest &&
         (ts.isArrowFunction(decl) ||
             !bodyReadsArguments(decl) ||
-            (decl.parameters.length > 0 && !isNodeEsmFile(decl.getSourceFile(), lowerer.program))))
+            (decl.parameters.nodes.length > 0 &&
+                !isNodeEsmFile(ts.getSourceFileOfNode(decl), lowerer.program))))
         return null;
-    const shapes = paramShapes(lowerer, decl.parameters);
+    const shapes = paramShapes(lowerer, decl.parameters.nodes);
     const retType = lowerer.checker.getReturnTypeOfSignature(sigs[0]);
     const ret = retType.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)
         ? DYN
@@ -755,15 +926,15 @@ function pureSingleCallSignatureOf(lowerer, t) {
         lowerer.checker.getConstructSignatures(t).length === 0 &&
         sigs[0].getTypeParameters().length === 0 &&
         sigs[0].getParameters().every((p) => {
-            const pDecl = lowerer.checker.valueDeclarationOf(p);
+            const pDecl = p.valueDeclaration;
             return !pDecl || !ts.isParameter(pDecl) || pDecl.dotDotDotToken === undefined;
         }) &&
         // A SYNTHESIZED rest param (tsc's `arguments` inference — no
         // valueDeclaration to carry the dotDotDot): param-count mismatch
         // against the signature's declaration; the whole value stays dyn.
         (() => {
-            const sigDecl = lowerer.checker.signatureDeclaration(sigs[0]);
-            const declParams = sigDecl !== undefined && ts.isFunctionLike(sigDecl) ? sigDecl.parameters : undefined;
+            const sigDecl = sigs[0].declaration;
+            const declParams = sigDecl !== undefined && ts.isFunctionLike(sigDecl) ? sigDecl.parameters.nodes : undefined;
             if (declParams !== undefined && declParams.length !== sigs[0].getParameters().length)
                 return false;
             // tsgo never synthesizes the `arguments` pseudo-rest into the
@@ -818,7 +989,7 @@ export function jsFuncNameOf(node, lowerer) {
         if (!symbol || seen.has(symbol))
             break;
         seen.add(symbol);
-        const declaration = lowerer.checker.valueDeclarationOf(symbol);
+        const declaration = symbol.valueDeclaration;
         if (declaration && ts.isFunctionDeclaration(declaration)) {
             n = declaration;
             break;
@@ -871,6 +1042,25 @@ function panicSafe(query, fallback) {
         throw e;
     }
 }
+/** The function's class expressions lower once per implicit-any instance.
+ * A function whose only implicit slots are destructured options and that
+ * is bound to a variable the implicit-instance probe rejects runs as one
+ * shared body, so its classes keep a single name. */
+function monomorphizedImplicit(lowerer, fn) {
+    const slots = implicitAnyParamSymbolsOf(lowerer, fn);
+    if (!slots)
+        return false;
+    if (slots.some((slot) => slot !== null))
+        return true;
+    let binding = fn.parent;
+    while (binding && ts.isParenthesizedExpression(binding))
+        binding = binding.parent;
+    if ((ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) &&
+        binding &&
+        ts.isVariableDeclaration(binding))
+        return implicitLocalFnNodeOf(lowerer, binding) !== null;
+    return true;
+}
 export class Lowerer {
     program;
     entry;
@@ -879,6 +1069,12 @@ export class Lowerer {
     checker;
     diags = [];
     fnSigsBySymbol = new Map();
+    /** Per file: whether it assigns `exports` and `module.exports`
+     * (cjs-exports-object.ts). */
+    cjsExportsAssignments = new Map();
+    /** Inline require() calls whose module edge closes a require cycle
+     * (LoadResult.inlineRequireCycleCalls). */
+    inlineRequireCycleCalls;
     /** 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. */
@@ -902,17 +1098,23 @@ export class Lowerer {
      * NaN, which lower to plain doubles (see nan-coded-reads.ts). Settled by
      * analyzeRuntimeOptionalArrayReads before any body lowers. */
     nanCodedReads = null;
+    /** Whether any implementation source spells `versions`
+     * (programMentionsVersions in builtins/process.ts). */
+    mentionsProcessVersions = undefined;
     stringIndexBoundsCache = null;
     /** Proofs that a string element read names an existing code unit. The
      * indexed-read analysis and expression lowering share one instance, so a
      * read's representation and its callers' signatures always agree. */
     get stringIndexBounds() {
-        this.stringIndexBoundsCache ??= new StringIndexBounds((node) => this.checker.getSymbolAtLocation(node) ?? null, (symbol) => this.checker.valueDeclarationOf(symbol), (node) => (this.typeOf(node).flags & ts.TypeFlags.StringLike) !== 0);
+        this.stringIndexBoundsCache ??= new StringIndexBounds((node) => this.checker.getSymbolAtLocation(node) ?? null, (symbol) => symbol.valueDeclaration, (node) => (this.typeOf(node).flags & ts.TypeFlags.StringLike) !== 0);
         return this.stringIndexBoundsCache;
     }
     /** Syntactic writes indexed once per JS scope. Symbol and RHS type
      * checks remain contextual to each binding probe. */
     jsBindingWritesByOwner = new Map();
+    /** JavaScript function declarations their own module reassigns
+     * (rebindable-functions.ts). */
+    rebindableFunctions = new Set();
     /** 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
@@ -1098,7 +1300,29 @@ export class Lowerer {
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings = null;
+    /** Generic lambdas lowering as erased values (lowerLambda): their own
+     * type parameters are bound to `unknown`, so lambdaSignature admits
+     * them. */
+    erasingLambdas = new Set();
+    /** Function expressions lowered against a fixed target signature with a
+     * tuple-typed `arguments` (typed-arguments.ts). */
+    typedArgumentsLambdas = new Set();
+    /** Const bindings holding a forwarded fixed tuple (`const args =
+     * arguments as any` in a typed-arguments function) → the tuple type. */
+    tupleAliasSymbols = new Map();
+    /** `??` expressions whose result is the optional callback's own function
+     * type (an adapted function default); their bindings take that type. */
+    nullishFuncResults = new Set();
+    /** The static names of the current generic instance's name-keyed
+     * function parameters (static-function-names.ts). */
+    staticFnNames = null;
+    /** Nesting depth of erased generic bodies being lowered (erased lambdas
+     * and erased instances). */
+    erasingDepth = 0;
     localClassInstantiations = [];
+    /** Instance types (by checker type id) of the local classes generic
+     * factory calls return, and the per-instance class each names. */
+    localClassInstanceTypes = new Map();
     /** 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
@@ -1112,6 +1336,25 @@ export class Lowerer {
      * typeParamBindings — the checker has no `T` to substitute, so the
      * binding rides the node-type accessor instead of mapType. */
     implicitParamTypes = 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. */
+    builtinClassAliases = new Map();
+    /** 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 = null;
+    /** Whether some program source can define a thenable
+     * (programMayDefineThenables). Null until first asked. */
+    thenablesMayBeDefined = null;
+    /** Lambdas lowered with checked-dynamic parameters (lambdaSignature):
+     * callbacks whose arguments are wider than their contextual overload. */
+    dynParamLambdas = new Set();
+    /** 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 = 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). */
@@ -1127,8 +1370,13 @@ export class Lowerer {
      * their symbol/node keys; no module-level cache should retain a pass. */
     classSymbolKeys = new Map();
     registeredClassSymbols = new Map();
+    /** Symbol-key identities by description, in resolution order (the slot
+     * ordinals of key-table keys — symbolKeyOf). */
+    symbolFieldIdentities = new Map();
     httpClientFnBindings = new Map();
     streamPropMutatedSyms = null;
+    /** Whether some source reads process.exitCode (processReadsExitCode). */
+    readsExitCode = null;
     requestInitPropMutatedSyms = null;
     emitterEventTable = null;
     emitterComputedPatterns = [];
@@ -1157,6 +1405,16 @@ export class Lowerer {
      * carry undefined at runtime. Identifier reads keep the union tag so
      * typeof and later boundaries observe the real value. */
     runtimeOptionalGlobals = new Set();
+    /** Per CommonJS file using top-level `this`: the global holding the
+     * object that stands for its original exports (lowerCjsTopLevelThis). */
+    cjsExportsThis = new Map();
+    /** Inline program-module require calls whose %init the enclosing member
+     * read or member call is already sequencing (cjs-inline-require.ts). */
+    inlineRequireInitDone = new Set();
+    /** Whether lowered code writes properties onto children, and what the
+     * program's JavaScript adds to them (handle-properties.ts). */
+    writesOntoChildren = false;
+    childAdditions = 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. */
@@ -1169,7 +1427,9 @@ export 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). */
     stageSourceTypes = new Map();
     /** Set when a match result lowers to execGroups/matchGroups, the inputs
      * of regex span folding. */
@@ -1179,6 +1439,10 @@ export class Lowerer {
      * declared optional binding to that read's bare type, so presence tests
      * on these bindings consult the stored tag instead. */
     runtimeOptionalAssignedSymbols = new Set();
+    /** Generic function declarations whose body can return an indexed read
+     * that misses.
+     * Each instance's result admits undefined (generic-functions.ts). */
+    runtimeOptionalGenericReturns = new Set();
     /** Concise callback/lambda returns promoted by the HOF callback prepass;
      * arrows have no declaration symbol to key in fnSigsBySymbol. */
     runtimeOptionalFunctionReturns = new Map();
@@ -1192,6 +1456,8 @@ export 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. */
     runtimeOptionalFields = new Set();
+    /** Bindings initialized by a Date's `toJSON()` (analyzeDateJsonResults). */
+    dateJsonBindings = new Set();
     /** 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. */
@@ -1239,7 +1505,7 @@ export class Lowerer {
         // directly from the aliased declaration as a final read-side hook, so
         // the initializer cannot fall back to a narrowing adapter.
         if (ts.isIdentifier(node) && fallback?.kind === "func") {
-            const decl = this.checker.valueDeclarationOf(symbol);
+            const decl = symbol.valueDeclaration;
             if (decl &&
                 ts.isVariableDeclaration(decl) &&
                 !decl.type &&
@@ -1265,6 +1531,63 @@ export class Lowerer {
         }
         return fallback ?? null;
     }
+    /** 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. */
+    excessJsContextualProperty(literal, contextual) {
+        const objects = contextual.filter((part) => !(part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)));
+        if (objects.length === 0)
+            return false;
+        // Only a destructuring pattern with a rest element is open; other
+        // inferred JS types keep their record lowering.
+        const fromJs = objects.every((part) => {
+            const sym = part.getSymbol();
+            return (sym !== undefined &&
+                sym.declarations.some((d) => {
+                    if (!isJsSourceFile(ts.getSourceFileOfNode(d)))
+                        return false;
+                    // The pattern itself, or the `= {}` default of a pattern parameter.
+                    const pattern = ts.isObjectLiteralExpression(d) &&
+                        d.parent !== undefined &&
+                        ts.isParameter(d.parent) &&
+                        d.parent.initializer === d
+                        ? d.parent.name
+                        : d;
+                    return (ts.isObjectBindingPattern(pattern) &&
+                        pattern.elements.nodes.some((element) => element.dotDotDotToken !== undefined));
+                }));
+        });
+        if (!fromJs)
+            return false;
+        return literal.properties.nodes.some((prop) => {
+            if (!prop.name || !(ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)))
+                return false;
+            const name = prop.name.text;
+            return objects.every((part) => !this.checker.getPropertyOfType(part, name));
+        });
+    }
+    /** 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) {
+        const receiver = panicSafe(() => this.mapTypeOf(this.typeOf(e.expression)), null);
+        if (receiver?.kind !== "record")
+            return null;
+        const shape = this.shapes.get(receiver.shapeId);
+        if (!shape || shape.tuple || !shape.indexValue || shape.indexValue.kind === "dyn")
+            return null;
+        const key = e.argumentExpression;
+        if ((ts.isStringLiteral(key) || ts.isNumericLiteral(key)) &&
+            shape.fields.some((field) => field.name === key.text))
+            return null;
+        const read = panicSafe(() => this.mapTypeOf(this.typeOf(e)), null);
+        if (read?.kind === "union" && this.armTag(read.unionId, UNDEFINED_T) >= 0)
+            return null;
+        return shape.indexValue;
+    }
     runtimeOptionalIdentifierValue(node) {
         if (!ts.isIdentifier(node) || this.chainRecvByNode.has(node))
             return null;
@@ -1284,45 +1607,53 @@ export class Lowerer {
             unionId: storage.type.unionId,
         };
     }
-    /** 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
-     * optional-read analysis, so ordinary assertions keep their generic
-     * checked-narrow behavior. */
-    runtimeOptionalSourceValue(node, value) {
-        const slot = this.deferredFieldSlot(value);
-        if (slot)
-            return slot;
+    /** 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) {
         let origin = node;
         while (ts.isParenthesizedExpression(origin))
             origin = origin.expression;
-        let optionalOrigin = ts.isElementAccessExpression(origin) || ts.isPropertyAccessExpression(origin);
+        if (ts.isElementAccessExpression(origin) || ts.isPropertyAccessExpression(origin))
+            return true;
         if (ts.isCallExpression(origin)) {
             const name = ts.isPropertyAccessExpression(origin.expression)
                 ? origin.expression.name
                 : origin.expression;
             const symbol = ts.isIdentifier(name) ? this.resolveValueSymbol(name) : undefined;
             const signature = symbol ? this.fnSigsBySymbol.get(symbol) : undefined;
-            optionalOrigin =
-                this.runtimeOptionalFunctionReturns.has(origin) ||
-                    (signature?.returnType.kind === "union" &&
-                        this.armTag(signature.returnType.unionId, UNDEFINED_T) >= 0);
+            return (this.runtimeOptionalFunctionReturns.has(origin) ||
+                (signature?.returnType.kind === "union" &&
+                    this.armTag(signature.returnType.unionId, UNDEFINED_T) >= 0));
         }
         if (ts.isIdentifier(origin)) {
             const local = this.resolveLocal(origin);
             const root = local ? this.runtimeOptionalRootOf(local) : null;
             const global = this.globalOf(origin);
-            optionalOrigin =
-                (!!root && this.runtimeOptionalStorageLocals.has(root)) ||
-                    (!!global &&
-                        (this.isRuntimeOptionalGlobal(global) ||
-                            (global.type.kind === "union" && this.armTag(global.type.unionId, UNDEFINED_T) >= 0)));
+            return ((!!root && this.runtimeOptionalStorageLocals.has(root)) ||
+                (!!global &&
+                    (this.isRuntimeOptionalGlobal(global) ||
+                        (global.type.kind === "union" && this.armTag(global.type.unionId, UNDEFINED_T) >= 0))));
         }
-        if (!optionalOrigin)
+        return false;
+    }
+    /** 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
+     * optional-read analysis, so ordinary assertions keep their generic
+     * checked-narrow behavior. */
+    runtimeOptionalSourceValue(node, value) {
+        const slot = this.deferredFieldSlot(value);
+        if (slot)
+            return slot;
+        if (!this.isRuntimeOptionalOrigin(node))
             return null;
         // A checked JavaScript indexed read can already be boxed. The checker
         // calls the element present, but that inference is not a runtime guard.
-        if (isJsSourceFile(node.getSourceFile()) &&
+        if (isJsSourceFile(ts.getSourceFileOfNode(node)) &&
             value.kind === "dynCheck" &&
             value.value.type.kind === "dyn")
             return value.value;
@@ -1338,7 +1669,7 @@ export 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, value, expected, member) {
+    runtimeOptionalPropertyReceiver(node, value, expected, member, action = "read") {
         const source = this.runtimeOptionalSourceValue(node, value);
         if (source?.type.kind !== "union")
             return null;
@@ -1376,7 +1707,7 @@ export class Lowerer {
                     type: BOOL,
                     loc,
                 },
-                then: nodeThrowExpr(1, "", `Cannot read properties of ${unit} (reading '${member}')`, expected, loc),
+                then: nodeThrowExpr(1, "", `Cannot ${action} properties of ${unit} (${action === "read" ? "reading" : "setting"} '${member}')`, expected, loc),
                 else_: result,
                 type: expected,
                 loc,
@@ -1543,10 +1874,28 @@ export class Lowerer {
     /** Settled generic class-rest metadata requires the historical emit
      * fallback so its fence can poison the original statement atomically. */
     requiresHistoricalOrderRelower = false;
+    /** 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 = false;
+    /** 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 = false;
+    /** 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. */
+    receiverTypeOverrides = new Map();
     /** 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. */
     shapeOrderHelperFinalizers = [];
+    /** Construction witnesses that choose each shape's enumeration order
+     * once lowering settles (key-order-witness.ts). */
+    keyOrder = new 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
@@ -1558,6 +1907,9 @@ export class Lowerer {
     /** Generated value helpers, keyed by operation and type. Callers own
      * their key prefixes; this includes more than structural conversions. */
     valueHelpers = new Map();
+    /** structuralNarrowing's assignable classes, keyed by static and
+     * narrowed class name. */
+    structuralClassPeers = new Map();
     /** 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. */
@@ -1578,6 +1930,12 @@ export class Lowerer {
     /** Method adapter names are owned by class-method-values. Looking them
      * up must not scan and retain every unrelated lifted function. */
     classMethodValueHelpers = new Set();
+    /** 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. */
+    methodLambdasInProgress = new Map();
     classMethodValueSelections = new Map();
     /** Callee names of every interned coercion helper whose CALL mints a
      * FRESH closure per evaluation (%fn.width.*, %fn.adapt.*,
@@ -1599,6 +1957,10 @@ export class Lowerer {
      * lifted lazily as module-level functions and interned per accessor
      * declaration: member reads call the getter (lower-exprs). */
     cjsAccessorFns = new Map();
+    /** Accessor exports' link-time values for ES-module importers, and the
+     * per-module flag that the copy already ran (cjsAccessorSnapshotStores). */
+    cjsAccessorSnapshots = new Map();
+    cjsSnapshotReady = new Map();
     /** 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. */
@@ -1623,6 +1985,8 @@ export class Lowerer {
      * so named imports, namespace reads, CommonJS bindings, and alias chains
      * all reuse one immortal zero-capture closure. */
     builtinCallableValueFns = new Map();
+    /** Each builtin function-value adapter's Node name, for boxed values. */
+    builtinCallableValueNames = new Map();
     /** 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
@@ -1664,6 +2028,10 @@ export class Lowerer {
     /** Named method slots observed before class collection need a callable
      * ABI and shared prototype descriptors instead of call-site specialization. */
     prototypeMethodAccesses = new Map();
+    /** Well-known symbol methods (`sym:iterator`) the program may replace
+     * through a symbol-keyed write: an instance or prototype property, or a
+     * reflection call. */
+    replacedSymbolMethods = new Set();
     /** Typed calls through class-backed protocols, by signature; class
      * dynamic dispatch adds their native arms (class-protocol-dispatch.ts). */
     protocolDispatches = new Map();
@@ -1681,6 +2049,9 @@ export class Lowerer {
      * base vtable signature is collected. Unused checked slots carry undefined. */
     virtualJsMethodArity = new Map();
     checkedVirtualJsMethods = new Set();
+    /** Overrides whose return narrows part of the base's union return; they
+     * return through the base's union ABI (overrideReturnAbi). */
+    unionReturnOverrides = new Set();
     checkedVirtualJsAccessors = new Set();
     checkedVirtualJsValueReturns = new Set();
     /** The class whose members are lowering — `super` binds lexically to it
@@ -1704,6 +2075,10 @@ export class Lowerer {
      * prepended by lowerFileInit so the bindings are live before any
      * top-level statement runs. */
     jsonInitActions = new Map();
+    /** CommonJS require() of JSON documents: the shared object per document
+     * and the calls reading it (json-require.ts). */
+    jsonRequireModules = new Map();
+    jsonRequireCalls = new Map();
     /** Dynamic `import("literal")` resolutions, keyed
      * `fileName\u0000specifier` (collectDynamicImports fills it during npm
      * collection; lowerDynamicImportCall reads it per site). */
@@ -1729,6 +2104,12 @@ export class Lowerer {
     workerTargets;
     workerTargetIdByPath = new Map();
     usesWorkers = false;
+    /** The program uses the WebAssembly API (builtins/webassembly.ts): the
+     * build translates the modules it discovers. */
+    usesWebAssembly = false;
+    /** The program calls WebAssembly.Module.customSections: translated
+     * modules keep their custom sections. */
+    usesWasmCustomSections = false;
     /** The program constructs a LifetimeRegion (lifetime-regions.ts). */
     usesLifetimeRegions = false;
     /** Per-directory answers of experimental-import.ts's declaration-file test. */
@@ -1739,6 +2120,12 @@ export class Lowerer {
     internTableHelpers = new Map();
     /** Each InternTable name's type arguments and first construction site. */
     internTableNames = new Map();
+    /** Each ThreadSlots name's type arguments (thread-slots.ts). */
+    threadSlotNames = new Map();
+    /** The family each `new ThreadSlots(...)` opens. */
+    threadSlotFamilies = new Map();
+    /** Classes used as ThreadSlots keys: their hierarchies carry a slot word. */
+    threadSlotKeys = new Set();
     forkTargetIdByPath = new Map();
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
@@ -1823,6 +2210,9 @@ export class Lowerer {
     // top level, top = the innermost nested function currently lowering).
     fnStack = [];
     liftedFns = [];
+    /** Runtime-provided classes used as values (defineClassValueConstruct),
+     * by IR class name. */
+    runtimeClassValues = new Map();
     /** One Error-method helper belongs to this lowering session. Its cached
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision = null;
@@ -1849,6 +2239,17 @@ export class Lowerer {
      * by class name (cycle-initialization.ts). */
     classInitFlags = new Map();
     cycleInitDeclarations = new Map();
+    /** Each class's constructor return plan by class name
+     * (constructor-returns.ts); null when no return can yield an object. */
+    constructorReturnPlans = new Map();
+    /** Pointer-guarded (`tdz`) module bindings declared without an
+     * initializer (`let f: T;`): an initialization flag tracks their
+     * declaration (markCycleEarlyBindings). */
+    uninitializedLexicalGlobals = new Map();
+    /** CommonJS require declarations whose bindings code running before the
+     * require can read, and those references (require-initialization.ts). */
+    requireInitFlags = new Map();
+    requireEarlyReferences = [];
     get ctx() {
         const top = this.fnStack[this.fnStack.length - 1];
         if (!top)
@@ -1884,6 +2285,16 @@ export class Lowerer {
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
      * and no module is built. */
     remainder;
+    /** `--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". */
+    tierMode;
+    generalNodeStreams;
+    dynNodeStreams;
+    /** Functions finishModule placed in the dynamic tier (ir/tiers.ts). */
+    dynamicFunctions = [];
+    /** Their IR, for coverage's dynamic statement count. */
+    dynamicBodies = [];
     /** 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. */
@@ -1908,6 +2319,9 @@ export class Lowerer {
     targetPlatform;
     /** LowererMode.startupCrash — buildMain opens %main with the throw. */
     startupCrash;
+    /** The project's tsconfig sets `checkJs`. */
+    projectCheckJs;
+    checkedJsFiles = new Map();
     /** Outbound native bindings by their source-level ambient name. */
     ffiImports;
     libraryCallbacks;
@@ -1946,6 +2360,33 @@ export class Lowerer {
      * package. Only populated while the registry is active; the remainder
      * pass skips it (attribution describes the build). */
     statsByFile = new Map();
+    /** 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. */
+    countedStatements = new Set();
+    failedStatements = new Set();
+    /** Adds `node` to the coverage totals unless it is already counted (the
+     * caller checks suppressStats). */
+    countStatement(node, file) {
+        if (this.countedStatements.has(node))
+            return;
+        this.countedStatements.add(node);
+        this.stats.statementsTotal++;
+        if (file !== undefined)
+            this.bumpFileStat(file, "total");
+    }
+    /** Counts `node` as failed unless it already is (the caller checks
+     * suppressStats). */
+    countStatementFailed(node, file) {
+        if (this.failedStatements.has(node))
+            return;
+        this.failedStatements.add(node);
+        this.stats.statementsFailed++;
+        if (file !== undefined)
+            this.bumpFileStat(file, "failed");
+    }
     /** 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). */
@@ -1964,25 +2405,31 @@ export class Lowerer {
         this.program = program;
         this.entry = entry;
         this.moduleOrder = moduleOrder;
+        // The mode's options, sorted by name; the values derived from them follow.
+        this.alreadyFlushed = mode.alreadyFlushed ?? new Set();
+        this.externalTypes = mode.externalTypes ?? new Map();
+        this.ffiBindingSymbols = mode.ffiBindingSymbols ?? null;
+        this.ffiImports = mode.ffiImports ?? [];
+        this.forkTargets = mode.forkTargets ?? [];
         this.frontendServices = mode.frontendServices;
+        this.inlineRequireCycleCalls = mode.inlineRequireCycleCalls ?? new Set();
+        this.libraryCallbacks = mode.libraryCallbacks ?? false;
+        this.projectCheckJs = mode.projectCheckJs ?? false;
         this.reachable = mode.reachable ?? null;
         this.remainder = mode.remainder ?? false;
-        this.alreadyFlushed = mode.alreadyFlushed ?? new Set();
-        this.targetPlatform = mode.targetPlatform ?? process.platform;
         this.startupCrash = mode.startupCrash ?? null;
-        this.ffiImports = mode.ffiImports ?? [];
-        this.libraryCallbacks = mode.libraryCallbacks ?? false;
+        this.targetPlatform = mode.targetPlatform ?? process.platform;
+        this.tierMode = mode.tierMode ?? "auto";
+        this.generalNodeStreams = mode.generalNodeStreams ?? false;
+        this.dynNodeStreams = this.generalNodeStreams && (mode.dynNodeStreams ?? false);
         this.workerTargets = mode.workerTargets ?? [];
         this.workerTargets.forEach((sf, id) => {
             this.workerTargetIdByPath.set(tsgoPath(resolve(sf.fileName)), id);
         });
-        this.forkTargets = mode.forkTargets ?? [];
         this.forkTargets.forEach((sf, id) => {
             this.forkTargetIdByPath.set(tsgoPath(resolve(sf.fileName)), id);
         });
         this.ffiImportsByName = new Map(this.ffiImports.map((entry) => [entry.name, entry]));
-        this.ffiBindingSymbols = mode.ffiBindingSymbols ?? null;
-        this.externalTypes = mode.externalTypes ?? new Map();
         this.externalTypeSpecifiersByFile =
             mode.externalTypeSpecifiersByFile ?? directExternalTypeSpecifiersByFile(this.externalTypes);
         this.checker = program.getTypeChecker();
@@ -1993,18 +2440,25 @@ export class Lowerer {
             classNamer: this.classNamer,
             resolveTypeParam: this.typeParamResolver,
             resolveTypeParamTs: this.typeParamTsResolver,
+            isErasing: () => this.erasingDepth > 0,
             genericClassInstance: (decl, ref, mapArgument) => this.genericClassInstanceType(decl, ref, mapArgument),
+            runtimeClassValue: (type) => runtimeClassValueOfType(this, type),
             mixinClassInstance: (decl) => this.mixinTypeContext && this.mixinTypeContext.classNode === decl
                 ? { kind: "object", className: this.mixinTypeContext.className }
                 : null,
-            localClassInstance: (decl) => {
+            localClassInstance: (decl, instanceType) => {
+                // A generic factory's local class, by the instance type a call of
+                // the factory produced (localClassResultInstance).
+                const instanceClass = instanceType && this.localClassInstanceTypes.get(instanceType.id);
+                if (instanceClass)
+                    return { kind: "object", className: instanceClass };
                 // Computed heritage can close over parameters of its factory.
                 // A speculative checker query outside that factory must not lower
                 // the extends expression in the caller's lexical scope.
                 if (!this.classes.has(this.classNamer(decl)) &&
                     !this.collectingExprClasses.has(decl) &&
-                    decl.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword &&
-                        clause.types.some((base) => {
+                    decl.heritageClauses?.nodes.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword &&
+                        clause.types.nodes.some((base) => {
                             const expression = base.expression;
                             if (ts.isCallExpression(expression))
                                 return true;
@@ -2032,13 +2486,14 @@ export class Lowerer {
                         continue;
                     if (this.localClassInstantiations.some((entry) => entry.owner === parent))
                         break;
-                    if (parent.typeParameters?.length ||
-                        (implicitMonoFile(parent.getSourceFile()) && implicitAnyParamSymbolsOf(this, parent)))
+                    if (parent.typeParameters?.nodes.length ||
+                        (implicitMonoFile(ts.getSourceFileOfNode(parent)) &&
+                            monomorphizedImplicit(this, parent)))
                         return null;
                 }
                 const className = this.classNamer(decl);
-                if (!this.collectingExprClasses.has(decl))
-                    this.lowerClassExpressionInfo(decl);
+                if (!this.collectingExprClasses.has(decl) && !this.collectLocalClassForType(decl))
+                    return null;
                 return { kind: "object", className };
             },
             mixinIntersectionInstance: (widened) => mixinIntersectionInstanceType(this, widened),
@@ -2047,18 +2502,23 @@ export class Lowerer {
             isNpmFile: this.isNpmFile,
             isExternalTypeFile: (sf) => this.externalTypeSpecifiersByFile.has(tsgoPath(resolve(sf.fileName))),
             typeMemo: this.typeMemo,
+            ...(this.generalNodeStreams ? { generalNodeStreams: true } : {}),
+            ...(this.dynNodeStreams ? { dynNodeStreams: true } : {}),
             canMemoizeType: () => this.typeParamBindings === null &&
                 this.typeParamTsBindings === null &&
                 this.mixinTypeContext === null,
             // fileTag is filled just below; the hook is only ever CALLED during
             // lowering, long after the constructor completes.
             isProgramFile: (sf) => this.fileTag.has(sf),
-            lifetimeRegionClass: (decl) => isExperimentalDeclarationFile(decl.getSourceFile(), this.experimentalFiles)
+            lifetimeRegionClass: (decl) => isExperimentalDeclarationFile(ts.getSourceFileOfNode(decl), this.experimentalFiles)
                 ? lifetimeRegionType(this)
                 : null,
-            internTableClass: (decl) => isExperimentalDeclarationFile(decl.getSourceFile(), this.experimentalFiles)
+            internTableClass: (decl) => isExperimentalDeclarationFile(ts.getSourceFileOfNode(decl), this.experimentalFiles)
                 ? internTableType(this)
                 : null,
+            threadSlotsClass: (decl) => isExperimentalDeclarationFile(ts.getSourceFileOfNode(decl), this.experimentalFiles)
+                ? threadSlotsType(this)
+                : null,
             moduleNamespaceId: (type) => this.moduleNamespaceIdOfType(type),
         };
         // Modules reachable only through literal import() joined
@@ -2070,11 +2530,25 @@ export class Lowerer {
         });
         if (this.moduleOrder.length === 0)
             this.fileTag.set(entry, "");
+        const jsDynamic = jsDynamicDeclarations(this.moduleOrder, this.checker);
+        if (jsDynamic.size > 0)
+            this.typeCtx.jsDynamicDeclaration = (decl) => jsDynamic.has(decl);
         this.registerBuiltinErrorClasses();
         registerBuiltinEmitterClass(this);
         registerBuiltinStreamClasses(this);
         registerBuiltinEventTargetClasses(this);
     }
+    /** 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) {
+        let checked = this.checkedJsFiles.get(sf);
+        if (checked === undefined) {
+            checked = isCheckedJsSourceFile(sf, this.projectCheckJs);
+            this.checkedJsFiles.set(sf, checked);
+        }
+        return checked;
+    }
     registerBuiltinErrorClasses() {
         return registerBuiltinErrorClasses(this);
     }
@@ -2084,10 +2558,50 @@ export class Lowerer {
         return this.classProtocols.usesCheckedIdentity(type);
     }
     /** 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) {
-        return this.classImplementedProtocol(type) || isWorkerHandleType(type, this.typeCtx);
+        return (this.opaqueValueType(type) ||
+            this.classImplementedProtocol(type) ||
+            isWorkerHandleType(type, this.typeCtx) ||
+            isFetchHandleType(type, this.typeCtx) ||
+            this.weakCollectionType(type) ||
+            this.stdlibHandleType(type, (part) => isEcdhType(this, part)));
+    }
+    /** A stdlib WeakMap or WeakSet, alone or with `null`/`undefined`. */
+    weakCollectionType(type) {
+        const weak = (part) => {
+            const symbol = part.getSymbol();
+            return (((symbol !== undefined && ts.symbolName(symbol) === "WeakMap") ||
+                (symbol !== undefined && ts.symbolName(symbol) === "WeakSet")) &&
+                symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && this.isStdlibFile(ts.getSourceFileOfNode(d))));
+        };
+        return this.stdlibHandleType(type, weak);
+    }
+    /** A type `handle` accepts, alone or with `null`/`undefined`. */
+    stdlibHandleType(type, handle) {
+        if (!type.isUnionType())
+            return handle(type);
+        const parts = ts.constituentTypes(type);
+        return (parts.some(handle) &&
+            parts.every((part) => (part.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0 || handle(part)));
+    }
+    /** `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. */
+    opaqueValueType(type) {
+        const opaque = (part) => (part.flags & (ts.TypeFlags.Unknown | ts.TypeFlags.NonPrimitive)) !== 0 ||
+            (this.checker.isArrayType(part) &&
+                this.checker.getTypeArguments(part).every(opaque));
+        if (!type.isUnionType())
+            return opaque(type);
+        const parts = ts.constituentTypes(type);
+        return (parts.some(opaque) &&
+            parts.every((part) => (part.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0 || opaque(part)));
     }
     /** The nominal identity of a checker module-namespace type. Program
      * modules use their normalized absolute source name; supported builtins
@@ -2098,7 +2612,7 @@ export class Lowerer {
             return null;
         if (sym.flags & ts.SymbolFlags.Alias)
             sym = this.checker.getAliasedSymbol(sym);
-        for (const decl of this.checker.declarationsOf(sym)) {
+        for (const decl of sym.declarations) {
             if (ts.isSourceFile(decl) &&
                 !decl.isDeclarationFile &&
                 !decl.fileName.endsWith(".cts") &&
@@ -2129,6 +2643,12 @@ export class Lowerer {
     builtinStreamInfoOf(symbol) {
         return builtinStreamInfoOf(this, symbol);
     }
+    builtinClassAliasOf(symbol) {
+        return builtinClassAliasOf(this, symbol);
+    }
+    defineClassValueConstruct(info) {
+        defineClassValueConstruct(this, info);
+    }
     /** Program-wide qualified name for a top-level declaration. */
     qualify(sf, name) {
         return `${this.fileTag.get(sf) ?? ""}${name}`;
@@ -2150,8 +2670,8 @@ export class Lowerer {
                 }
                 return false;
             })()
-            ? this.qualify(decl.getSourceFile(), `%cx${decl.getStart()}.${decl.name?.text ?? ""}`)
-            : this.qualify(decl.getSourceFile(), nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"));
+            ? this.qualify(ts.getSourceFileOfNode(decl), `%cx${ts.tokenStartOfNode(decl)}.${decl.name?.text ?? ""}`)
+            : this.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"));
         for (let index = this.localClassInstantiations.length - 1; index >= 0; index--) {
             const entry = this.localClassInstantiations[index];
             for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
@@ -2196,8 +2716,10 @@ export class Lowerer {
             ts.isPropertyAccessExpression(ident.parent) &&
             ident.parent.name === ident) {
             const recv = ident.parent.expression;
-            if (ts.isIdentifier(recv) && this.cjsLocalModuleBindingOf(recv)) {
-                const dep = this.localModuleBindingDepOf(recv);
+            if (this.cjsLocalModuleBindingOf(recv)) {
+                const dep = ts.isIdentifier(recv)
+                    ? this.localModuleBindingDepOf(recv)
+                    : this.cjsModuleRefDepOf(recv);
                 const exported = dep ? this.cjsModuleExportSymbol(dep, ident.text) : undefined;
                 // A createRequire call is typed as `any`, so tsgo can manufacture a
                 // transient property symbol with no relation to the target module.
@@ -2290,7 +2812,7 @@ export class Lowerer {
         }
         if (ts.isCallExpression(value)) {
             if (value.expression.kind === ts.SyntaxKind.ImportKeyword) {
-                const spec = value.arguments[0];
+                const spec = value.arguments.nodes[0];
                 return spec !== undefined &&
                     ts.isStringLiteralLike(spec) &&
                     this.externalTypes.has(spec.text)
@@ -2299,8 +2821,8 @@ export class Lowerer {
             }
             if (ts.isIdentifier(value.expression) &&
                 value.expression.text === "require" &&
-                value.arguments.length === 1) {
-                const spec = value.arguments[0];
+                value.arguments.nodes.length === 1) {
+                const spec = value.arguments.nodes[0];
                 if (ts.isStringLiteralLike(spec) && this.externalTypes.has(spec.text))
                     return spec.text;
             }
@@ -2337,7 +2859,7 @@ export class Lowerer {
      * every project-module spelling. */
     moduleSourceFileOf(from, spec) {
         const moduleSymbol = this.checker.getSymbolAtLocation(spec);
-        for (const decl of moduleSymbol ? this.checker.declarationsOf(moduleSymbol) : []) {
+        for (const decl of moduleSymbol ? moduleSymbol.declarations : []) {
             if (ts.isSourceFile(decl))
                 return decl;
         }
@@ -2373,9 +2895,7 @@ export class Lowerer {
         if (!ts.isIdentifier(value))
             return null;
         const symbol = this.checker.getSymbolAtLocation(value);
-        const namespaceDecl = symbol
-            ? this.checker.declarationsOf(symbol).find(ts.isNamespaceImport)
-            : undefined;
+        const namespaceDecl = symbol ? symbol.declarations.find(ts.isNamespaceImport) : undefined;
         if (namespaceDecl === undefined)
             return null;
         const importDecl = namespaceDecl.parent?.parent;
@@ -2383,7 +2903,7 @@ export class Lowerer {
             return null;
         if (this.externalTypes.has(importDecl.moduleSpecifier.text))
             return importDecl.moduleSpecifier.text;
-        const dep = this.moduleSourceFileOf(importDecl.getSourceFile(), importDecl.moduleSpecifier);
+        const dep = this.moduleSourceFileOf(ts.getSourceFileOfNode(importDecl), importDecl.moduleSpecifier);
         return dep !== null && !dep.isDeclarationFile
             ? this.externalTypeSpecifierOfModuleExport(dep, member, new Set(), new Set())
             : null;
@@ -2392,7 +2912,7 @@ export class Lowerer {
         if (symbol === undefined || seenSymbols.has(symbol))
             return null;
         seenSymbols.add(symbol);
-        const declarations = this.checker.declarationsOf(symbol);
+        const declarations = symbol.declarations;
         // Route-aware alias hops run before declaration-file ownership. An
         // exact import must keep the specifier it actually named, rather than
         // inheriting whichever alias happened to register the shared file last.
@@ -2439,13 +2959,13 @@ export class Lowerer {
             // property accesses resolve their selected member separately above.
             if (importedName === null)
                 return null;
-            const dep = this.moduleSourceFileOf(decl.getSourceFile(), specNode);
+            const dep = this.moduleSourceFileOf(ts.getSourceFileOfNode(decl), specNode);
             return dep !== null && !dep.isDeclarationFile
                 ? this.externalTypeSpecifierOfModuleExport(dep, importedName, seenSymbols, seenExports)
                 : null;
         }
         for (const decl of declarations) {
-            const owners = this.externalTypeSpecifiersByFile.get(tsgoPath(resolve(decl.getSourceFile().fileName)));
+            const owners = this.externalTypeSpecifiersByFile.get(tsgoPath(resolve(ts.getSourceFileOfNode(decl).fileName)));
             if (owners !== undefined && owners.length > 0)
                 return owners[0];
         }
@@ -2468,9 +2988,7 @@ export class Lowerer {
         for (let hop = 0; sym !== undefined && hop < 32; hop++) {
             if (hop > 0 && sym.flags & ts.SymbolFlags.Alias && this.globalsBySymbol.has(sym))
                 return sym;
-            const d = this.checker
-                .declarationsOf(sym)
-                .find((x) => ts.isImportClause(x) || ts.isImportSpecifier(x) || ts.isExportSpecifier(x));
+            const d = sym.declarations.find((x) => ts.isImportClause(x) || ts.isImportSpecifier(x) || ts.isExportSpecifier(x));
             let spec;
             let name;
             if (d && ts.isImportClause(d) && ts.isImportDeclaration(d.parent)) {
@@ -2491,7 +3009,7 @@ export class Lowerer {
             }
             if (d === undefined || spec === undefined || !ts.isStringLiteral(spec) || name !== "default")
                 return null;
-            const dep = resolveImport(this.program, d.getSourceFile(), spec.text);
+            const dep = resolveImport(this.program, ts.getSourceFileOfNode(d), spec.text);
             if (!dep)
                 return null;
             sym = defaultExportSymbolOf(this, dep) ?? undefined;
@@ -2521,7 +3039,7 @@ export class Lowerer {
      * see resolveValueSymbol. Null when `symbol` is not such a property (or
      * the property's value is not a plain identifier reference). */
     cjsExportValueSymbol(symbol) {
-        const d = this.checker.declarationsOf(symbol)[0];
+        const d = symbol.declarations[0];
         if (!d)
             return null;
         // MEMBER-form class exports (`exports.C = C` — commander's error.js):
@@ -2563,8 +3081,6 @@ export class Lowerer {
                 : null;
         if (!assign || assign.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
             return null;
-        if (!ts.isIdentifier(assign.right))
-            return null;
         const stmt = assign.parent;
         if (!stmt || !ts.isExpressionStatement(stmt) || !ts.isSourceFile(stmt.parent))
             return null;
@@ -2575,12 +3091,39 @@ export class Lowerer {
             return null;
         if (cjsExportDiscardReason(stmt) !== null)
             return null;
+        // `module.exports.C = require('./c')` over a module whose whole export
+        // is a class identifier: the same alias plumbing; the statement keeps
+        // the require's module evaluation at its position.
+        const required = this.memberExportRequiredClass(assign.right);
+        if (required !== undefined)
+            return required;
+        if (!ts.isIdentifier(assign.right))
+            return null;
         let value = this.checker.getSymbolAtLocation(assign.right);
         if (!value)
             return null;
         if (value.flags & ts.SymbolFlags.Alias)
             value = this.checker.getAliasedSymbol(value);
-        const isClass = this.checker.declarationsOf(value).some((decl) => ts.isClassDeclaration(decl));
+        const isClass = value.declarations.some((decl) => ts.isClassDeclaration(decl));
+        return isClass ? value : 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) {
+        const req = inlineProgramRequireOf(this, expr);
+        if (req === null)
+            return undefined;
+        const whole = cjsWholeExportValueOf(req.dep);
+        if (whole === null || !ts.isIdentifier(whole.rhs))
+            return null;
+        let value = this.checker.getSymbolAtLocation(whole.rhs);
+        if (!value)
+            return null;
+        if (value.flags & ts.SymbolFlags.Alias)
+            value = this.checker.getAliasedSymbol(value);
+        const isClass = value.declarations.some((decl) => ts.isClassDeclaration(decl));
         return isClass ? value : null;
     }
     /** The CommonJS JS module a DEFAULT-import binding's declaration loads
@@ -2597,19 +3140,33 @@ export class Lowerer {
         const spec = importDecl.moduleSpecifier.text;
         // Project aliases/self-references resolve through the same entry point as
         // relative imports; an opted-in --npm-static package is the fallback.
-        const dep = resolveImport(this.program, importDecl.getSourceFile(), spec) ??
-            npmStaticDepSf7(this.program, importDecl.getSourceFile(), spec);
+        const dep = resolveImport(this.program, ts.getSourceFileOfNode(importDecl), spec) ??
+            npmStaticDepSf7(this.program, ts.getSourceFileOfNode(importDecl), spec);
         if (!dep || !isJsSourceFile(dep) || isNodeEsmFile(dep, this.program))
             return null;
         return dep;
     }
+    /** 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) {
+        const inline = inlineNamespaceRequireOf(this, expr);
+        if (inline !== null)
+            return inline.dep;
+        const interop = tscInteropModuleOf(this, expr);
+        return interop !== null && cjsNamespaceModule(this, interop.dep) ? interop.dep : null;
+    }
+    /** The table module a CommonJS module binding identifier names. */
+    cjsModuleBindingDepOf(expr) {
+        return this.localModuleBindingDepOf(expr);
+    }
     /** 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
      * member-symbol fallback and namespace classification in lockstep. */
     localModuleBindingDepOf(expr) {
         const sym = this.checker.getSymbolAtLocation(expr);
-        const decls = sym ? this.checker.declarationsOf(sym) : [];
+        const decls = sym ? sym.declarations : [];
         const decl = decls.find(ts.isImportClause) ?? decls[0];
         if (!decl)
             return null;
@@ -2617,10 +3174,17 @@ export class Lowerer {
             return this.cjsDefaultImportDepOf(decl);
         if (!ts.isVariableDeclaration(decl) || !ts.isIdentifier(decl.name) || !decl.initializer)
             return null;
+        {
+            const interop = tscInteropModuleOf(this, expr);
+            if (interop !== null)
+                return cjsNamespaceModule(this, interop.dep) ? interop.dep : null;
+        }
         const directSpec = requireSpecOf(decl.initializer);
         if (directSpec !== null) {
-            return (resolveImport(this.program, decl.getSourceFile(), directSpec, "require") ??
-                npmStaticDepSf7(this.program, decl.getSourceFile(), directSpec, "require"));
+            if (isJsonRequireDecl(this, decl))
+                return null;
+            return (resolveImport(this.program, ts.getSourceFileOfNode(decl), directSpec, "require") ??
+                npmStaticDepSf7(this.program, ts.getSourceFileOfNode(decl), directSpec, "require"));
         }
         return createRequireProgramModuleOf(this, decl.initializer)?.dep ?? null;
     }
@@ -2631,9 +3195,7 @@ export class Lowerer {
      * static storage or callable/class metadata. */
     createRequireWholeExportSymbolOf(ident) {
         const binding = this.checker.getSymbolAtLocation(ident);
-        const decl = binding
-            ? this.checker.declarationsOf(binding).find(ts.isVariableDeclaration)
-            : undefined;
+        const decl = binding ? binding.declarations.find(ts.isVariableDeclaration) : undefined;
         if (!decl || !ts.isIdentifier(decl.name) || !decl.initializer)
             return null;
         const target = createRequireProgramModuleOf(this, decl.initializer);
@@ -2643,9 +3205,7 @@ export class Lowerer {
         let symbol = moduleSym?.getExports().get("export=");
         if (!symbol)
             return null;
-        const wholeAssignment = this.checker
-            .declarationsOf(symbol)
-            .find((d) => {
+        const wholeAssignment = symbol.declarations.find((d) => {
             if (!ts.isBinaryExpression(d) ||
                 !ts.isExpressionStatement(d.parent) ||
                 !ts.isSourceFile(d.parent.parent))
@@ -2660,6 +3220,10 @@ export class Lowerer {
         let rhs = wholeAssignment.right;
         while (ts.isParenthesizedExpression(rhs))
             rhs = rhs.expression;
+        // A pure re-export (`module.exports = require("./core")`) is the inner
+        // module's export table, read like any namespace binding.
+        if (inlineProgramRequireOf(this, rhs) !== null && !this.globalsByDeclNode.has(wholeAssignment))
+            return null;
         if (ts.isIdentifier(rhs)) {
             const value = this.checker.getSymbolAtLocation(rhs);
             if (value) {
@@ -2678,9 +3242,7 @@ export class Lowerer {
      * target module's real export symbol. */
     createRequireDestructuredExportSymbolOf(ident) {
         const binding = this.checker.getSymbolAtLocation(ident);
-        const element = binding
-            ? this.checker.declarationsOf(binding).find(ts.isBindingElement)
-            : undefined;
+        const element = binding ? binding.declarations.find(ts.isBindingElement) : undefined;
         if (!element ||
             element.name === undefined ||
             !ts.isIdentifier(element.name) ||
@@ -2709,8 +3271,10 @@ export class Lowerer {
      * symbols → resolveValueSymbol); the bare value keeps the
      * namespace-object fence, like ESM namespace imports of builtins. */
     cjsLocalModuleBindingOf(expr) {
+        // An inline `require("./x")` over a table module reads its members like
+        // a binding (cjs-inline-require.ts sequences the module's %init).
         if (!ts.isIdentifier(expr))
-            return false;
+            return this.cjsModuleRefDepOf(expr) !== null;
         const sym = this.checker.getSymbolAtLocation(expr);
         if (this.localModuleBindingDepOf(expr) === null)
             return false;
@@ -2725,7 +3289,10 @@ export class Lowerer {
         // the object literal) keep the namespace reading — member accesses
         // resolve through the table's property symbols.
         if (sym && sym.flags & ts.SymbolFlags.Alias) {
-            const d = this.checker.declarationsOf(this.checker.getAliasedSymbol(sym))[0];
+            // `module.exports = TypeError`: the binding IS the builtin global.
+            if (this.isStdlibSymbol(this.checker.getAliasedSymbol(sym)))
+                return false;
+            const d = this.checker.getAliasedSymbol(sym).declarations[0];
             if (d && (ts.isClassDeclaration(d) || ts.isFunctionDeclaration(d)))
                 return false;
             if (d && ts.isVariableDeclaration(d)) {
@@ -2795,7 +3362,7 @@ export class Lowerer {
                 g.type = this.runtimeOptionalBindingType(ident, g.type);
             return g;
         }
-        for (const d of this.checker.declarationsOf(symbol)) {
+        for (const d of symbol.declarations) {
             const byDecl = this.globalsByDeclNode.get(d);
             if (byDecl)
                 return byDecl;
@@ -2825,6 +3392,16 @@ export class Lowerer {
             const id = `%g.${tag}%loaded`;
             this.moduleGuardOf.set(fp.sf, id);
             this.globalsList.push({ id, name: "%loaded", type: BOOL, mutable: true });
+            if (usesCjsTopLevelThis(this, fp.sf) || usesCjsExportsIdentity(this, fp.sf)) {
+                const exportsThis = {
+                    id: `%g.${tag}%exportsThis`,
+                    name: "%exportsThis",
+                    type: DYN,
+                    mutable: true,
+                };
+                this.globalsList.push(exportsThis);
+                this.cjsExportsThis.set(fp.sf, exportsThis);
+            }
         }
         // A module is intrinsically async when an await/for-await occurs
         // outside every nested function-like boundary. Then propagate that
@@ -2944,6 +3521,59 @@ export class Lowerer {
             if (!indexOf.has(fp.sf))
                 visit(fp.sf);
     }
+    /** 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) {
+        const loc = locOf(node);
+        const fromDependency = /[\\/]node_modules[\\/]/.test(ts.getSourceFileOfNode(node).fileName);
+        return {
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "punycode.warn",
+                args: [
+                    { kind: "boolLit", value: false, type: BOOL, loc },
+                    { kind: "boolLit", value: !fromDependency, type: BOOL, loc },
+                ],
+                type: VOID,
+                loc,
+            },
+            loc,
+        };
+    }
+    /** 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() {
+        const imports = this.moduleOrder.some((sf) => sf.statements.nodes.some((stmt) => ((ts.isImportDeclaration(stmt) && !erasedTypeOnlyImport(stmt)) ||
+            (ts.isExportDeclaration(stmt) && !stmt.isTypeOnly)) &&
+            stmt.moduleSpecifier !== undefined &&
+            ts.isStringLiteral(stmt.moduleSpecifier) &&
+            canonicalBuiltinModule(stmt.moduleSpecifier.text) === "punycode"));
+        if (!imports)
+            return [];
+        const loc = { file: this.entry.fileName, start: 0, end: 0 };
+        return [
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "punycode.warn",
+                    args: [
+                        { kind: "boolLit", value: true, type: BOOL, loc },
+                        { kind: "boolLit", value: true, type: BOOL, loc },
+                    ],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            },
+        ];
+    }
     /** 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
@@ -2953,6 +3583,8 @@ export class Lowerer {
      * their external dependencies by name). Null for everything else
      * (builtins load nothing; the rest kept its preflight fence). */
     requireInitStmt(spec, node) {
+        if (canonicalBuiltinModule(spec) === "punycode")
+            return this.punycodeRequireWarning(node);
         // Project requires resolve within the program; another bare require can
         // be a program-module edge when it names an opted-in --npm-static package
         // (one package requiring another — the resolution answered its shipped
@@ -2960,8 +3592,8 @@ export class Lowerer {
         // Without the guarded %init call at this position
         // those globals stay uninitialized: the dep's module body would never
         // run.
-        const dep = resolveImport(this.program, node.getSourceFile(), spec, "require") ??
-            npmStaticDepSf7(this.program, node.getSourceFile(), spec, "require");
+        const dep = resolveImport(this.program, ts.getSourceFileOfNode(node), spec, "require") ??
+            npmStaticDepSf7(this.program, ts.getSourceFileOfNode(node), spec, "require");
         if (!dep || dep.fileName.endsWith(".json"))
             return null;
         if (this.asyncInitFiles.has(dep)) {
@@ -2976,7 +3608,7 @@ export class Lowerer {
             expr: { kind: "call", callee: initName, args: [], type: VOID, loc },
             loc,
         };
-        const parentModule = this.cjsModuleIdOf.get(node.getSourceFile());
+        const parentModule = this.cjsModuleIdOf.get(ts.getSourceFileOfNode(node));
         const childModule = this.cjsModuleIdOf.get(dep);
         if (parentModule === undefined || childModule === undefined)
             return init;
@@ -3018,6 +3650,97 @@ export 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) {
+        const nullable = dateJsonType(this);
+        for (const { sf } of parts) {
+            if (!sf.text.includes("toJSON"))
+                continue;
+            ts.walkPreorder(sf, (node) => {
+                // `x = d.toJSON()`: the checker narrows x to string after the
+                // assignment, so its reads must stay checked.
+                if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isIdentifier(node.left) &&
+                    isDateJsonSource(this, node.right)) {
+                    const symbol = this.checker.getSymbolAtLocation(node.left);
+                    if (symbol)
+                        this.dateJsonBindings.add(symbol);
+                    return undefined;
+                }
+                if (!ts.isVariableDeclaration(node) || !node.initializer)
+                    return undefined;
+                if (!ts.isIdentifier(node.name))
+                    return undefined;
+                const symbol = this.checker.getSymbolAtLocation(node.name);
+                if (!symbol)
+                    return undefined;
+                let init = node.initializer;
+                while (ts.isParenthesizedExpression(init))
+                    init = init.expression;
+                if (isDateJsonSource(this, init)) {
+                    this.dateJsonBindings.add(symbol);
+                    // An annotation keeps its declared storage.
+                    if (!node.type)
+                        this.runtimeOptionalBindingTypes.set(symbol, nullable);
+                    return undefined;
+                }
+                if (node.type)
+                    return undefined;
+                if (!ts.isObjectLiteralExpression(init))
+                    return undefined;
+                const declared = this.mapTypeOf(this.typeOf(node.name));
+                if (declared?.kind !== "record")
+                    return undefined;
+                let widened = declared;
+                for (const property of init.properties.nodes) {
+                    const value = ts.isPropertyAssignment(property)
+                        ? property.initializer
+                        : ts.isShorthandPropertyAssignment(property)
+                            ? property.name
+                            : null;
+                    const name = property.name && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))
+                        ? property.name.text
+                        : null;
+                    if (value && name !== null && isDateJsonSource(this, value))
+                        widened = this.runtimeOptionalRecordField(widened, name, nullable);
+                }
+                if (widened !== declared)
+                    this.runtimeOptionalBindingTypes.set(symbol, widened);
+                return undefined;
+            });
+        }
+    }
+    /** 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) {
+        for (const { sf } of parts) {
+            for (const statement of sf.statements.nodes) {
+                if (!ts.isVariableStatement(statement))
+                    continue;
+                for (const decl of statement.declarationList.declarations.nodes) {
+                    if (!ts.isIdentifier(decl.name) || !isGuardedRecordRead(this, decl))
+                        continue;
+                    const global = this.globalOf(decl.name);
+                    const symbol = this.resolveValueSymbol(decl.name);
+                    if (!global || !symbol || global.tdz || this.runtimeOptionalBindingTypes.has(symbol))
+                        continue;
+                    const widened = global.type.kind === "union"
+                        ? this.withUndefinedArmOf(global.type)
+                        : this.withUndefinedArm(global.type);
+                    if (!widened || typeEquals(widened, global.type))
+                        continue;
+                    global.type = widened;
+                    this.runtimeOptionalBindingTypes.set(symbol, widened);
+                }
+            }
+        }
+    }
     analyzeRuntimeOptionalArrayReads(parts) {
         const provenance = RuntimeOptionalProvenance.fromEnvironment();
         // The site whose value the current promotion follows (debug only).
@@ -3138,7 +3861,7 @@ export class Lowerer {
             const symbol = (ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) && fn.name
                 ? symbolOf(fn.name)
                 : null;
-            const index = fn.parameters.indexOf(parameter);
+            const index = fn.parameters.nodes.indexOf(parameter);
             return (symbol && signatureBySymbol.get(symbol)?.params[index]?.type) ?? null;
         };
         const returnTypeOf = (fn) => {
@@ -3147,7 +3870,7 @@ export class Lowerer {
         };
         const recordFlows = new RecordFlowClasses(sourceFiles, {
             symbolOf,
-            declarationOf: (symbol) => this.checker.valueDeclarationOf(symbol),
+            declarationOf: (symbol) => symbol.valueDeclaration,
             mayBeRecord: (node) => {
                 if (node.parent && ts.isParameter(node.parent))
                     return plainRecordShape(parameterType(node)) !== null;
@@ -3172,11 +3895,12 @@ export class Lowerer {
         const recordParameterSlots = new Map();
         const nanCoded = new NanCodedReads({
             symbolOf,
-            declarationOf: (symbol) => this.checker.valueDeclarationOf(symbol),
+            declarationOf: (symbol) => symbol.valueDeclaration,
             bytesElemOf: (receiver) => {
                 const t = mappedOrNull(receiver);
                 return t?.kind === "bytes" ? t.elem : null;
             },
+            isNumberRecordRead: (read) => this.optionalIndexSignatureRead(read)?.kind === "f64",
             isNumber: (node) => mappedOrNull(node)?.kind === "f64",
             isString: (node) => mappedOrNull(node)?.kind === "string",
             hasLength: (node) => {
@@ -3218,7 +3942,7 @@ export class Lowerer {
             const seen = new Set();
             while (symbol && !signatureBySymbol.has(symbol) && !seen.has(symbol)) {
                 seen.add(symbol);
-                const declaration = this.checker.valueDeclarationOf(symbol);
+                const declaration = symbol.valueDeclaration;
                 if (declaration && ts.isMethodDeclaration(declaration)) {
                     symbol = symbolOf(declaration.name);
                 }
@@ -3317,14 +4041,109 @@ export class Lowerer {
             // every consumer treats undefined like NaN.
             if (kind === "bytes")
                 return !nanCoded.isNumericRead(e);
+            if (kind === "record")
+                return this.optionalIndexSignatureRead(e) !== null && !nanCoded.isNumericRead(e);
             return kind === "array";
         };
+        /** `r.name` where the name resolves to the receiver's index signature. */
+        const isRecordIndexPropertyRead = (e) => {
+            // A name that resolves to a declared member is not an index read, and
+            // only a receiver with an index signature maps to an indexed record.
+            if (symbolOf(e.name))
+                return false;
+            const receiverType = this.typeOf(e.expression);
+            if (this.checker.getIndexInfosOfType(receiverType).length === 0)
+                return false;
+            const receiver = this.mapTypeOf(receiverType);
+            if (receiver?.kind !== "record")
+                return false;
+            const shape = this.shapes.get(receiver.shapeId);
+            if (!shape || shape.tuple || !shape.indexValue || shape.indexValue.kind === "dyn")
+                return false;
+            if (shape.fields.some((field) => field.name === e.name.text))
+                return false;
+            const read = this.mapTypeOf(this.typeOf(e));
+            return !(read?.kind === "union" && this.armTag(read.unionId, UNDEFINED_T) >= 0);
+        };
+        /** An optional value in a generic body, where element types are type
+         * parameters with no IR mapping yet: an element read of an array or a
+         * read of a string index signature, judged on checker types. */
+        const genericClassMethods = [];
+        for (const sf of sourceFiles) {
+            if (isJsSourceFile(sf) || sf.isDeclarationFile)
+                continue;
+            ts.walkPreorder(sf, (node) => {
+                if (!ts.isClassDeclaration(node))
+                    return undefined;
+                const genericClass = (node.typeParameters?.nodes.length ?? 0) > 0;
+                for (const member of node.members.nodes)
+                    if (ts.isMethodDeclaration(member) &&
+                        member.body &&
+                        (genericClass || (member.typeParameters?.nodes.length ?? 0) > 0))
+                        genericClassMethods.push(member);
+                return undefined;
+            });
+        }
+        const genericMayBeOptional = (node) => {
+            if (explicitlyNonNull(node))
+                return false;
+            if (mayBeOptional(node))
+                return true;
+            const e = peel(node);
+            if (ts.isConditionalExpression(e))
+                return genericMayBeOptional(e.whenTrue) || genericMayBeOptional(e.whenFalse);
+            if (ts.isBinaryExpression(e)) {
+                const op = e.operatorToken.kind;
+                if (op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken)
+                    return genericMayBeOptional(e.right);
+                if (op === ts.SyntaxKind.AmpersandAmpersandToken)
+                    return genericMayBeOptional(e.left) || genericMayBeOptional(e.right);
+                return false;
+            }
+            if (ts.isIdentifier(e)) {
+                // A binding initialized from such a read and never reassigned.
+                const symbol = symbolOf(e);
+                const decl = symbol ? symbol.valueDeclaration : undefined;
+                return (symbol !== null &&
+                    !reassigned.has(symbol) &&
+                    decl !== undefined &&
+                    ts.isVariableDeclaration(decl) &&
+                    decl.initializer !== undefined &&
+                    ts.isIdentifier(decl.name) &&
+                    !provenPresent(e, symbol) &&
+                    genericIndexedRead(decl.initializer));
+            }
+            return genericIndexedRead(e);
+        };
+        const genericIndexedRead = (node) => {
+            const e = peel(node);
+            if (!ts.isElementAccessExpression(e) || explicitlyNonNull(node))
+                return false;
+            const read = typeOrNull(e);
+            if (!read || (read.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Any)) !== 0)
+                return false;
+            if (read.isUnionType() &&
+                ts.constituentTypes(read).some((t) => (t.flags & ts.TypeFlags.Undefined) !== 0))
+                return false;
+            const receiver = typeOrNull(e.expression);
+            if (!receiver || this.checker.isTupleType(receiver))
+                return false;
+            if (this.checker.isArrayType(receiver))
+                return true;
+            const key = e.argumentExpression;
+            if ((ts.isStringLiteral(key) || ts.isNumericLiteral(key)) &&
+                this.checker.getPropertyOfType(receiver, key.text) !== undefined)
+                return false;
+            return this.checker
+                .getIndexInfosOfType(receiver)
+                .some((info) => (info.keyType.flags & ts.TypeFlags.StringLike) !== 0);
+        };
         const isDynamicObjectEntryRead = (node) => {
             const read = peel(node);
             if (!ts.isElementAccessExpression(read) || !ts.isIdentifier(read.expression))
                 return false;
             const source = symbolOf(read.expression);
-            const declaration = source ? this.checker.valueDeclarationOf(source) : undefined;
+            const declaration = source ? source.valueDeclaration : undefined;
             if (!declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer)
                 return false;
             const init = peel(declaration.initializer);
@@ -3333,14 +4152,17 @@ export class Lowerer {
             if (init.expression.name.text !== "entries" ||
                 !this.isStdlibGlobal(init.expression.expression, "Object"))
                 return false;
-            const object = init.arguments[0];
+            const object = init.arguments.nodes[0];
             const objectType = object ? this.mapTypeOf(this.typeOf(object)) : null;
             return objectType?.kind === "dyn";
         };
         const addUndefined = (t) => {
             if (t.kind === "union")
                 return this.armTag(t.unionId, UNDEFINED_T) >= 0 ? t : (this.withUndefinedArmOf(t) ?? t);
-            if (t.kind === "void" || t.kind === "dyn" || t.kind === "generator")
+            // A Date has no undefined-armed union (it is not a union arm kind):
+            // like a generator it keeps its type, and the site that would store
+            // undefined into it keeps its own diagnostic.
+            if (t.kind === "void" || t.kind === "dyn" || t.kind === "generator" || t.kind === "date")
                 return t;
             return this.withUndefinedArm(t);
         };
@@ -3376,17 +4198,45 @@ export class Lowerer {
         // Such a binding reads `T | undefined`, so a typed parameter, local or
         // field it flows into widens like any other missing element read.
         const holeyIterationSymbols = new Set();
+        // `xs[i] as number` and `stack.pop() as number`: an assertion to a type
+        // without undefined checks the value (lowerAsExpression narrows to the
+        // asserted type and throws a TypeError for undefined), so its result is
+        // never undefined.
+        const assertsDefined = (node) => {
+            let e = node;
+            while (ts.isParenthesizedExpression(e))
+                e = e.expression;
+            if (!ts.isAsExpression(e) && !ts.isTypeAssertion(e))
+                return false;
+            const asserted = typeOrNull(e);
+            const admits = (type) => (type.flags &
+                (ts.TypeFlags.Any |
+                    ts.TypeFlags.Unknown |
+                    ts.TypeFlags.Undefined |
+                    ts.TypeFlags.Void |
+                    ts.TypeFlags.TypeParameter)) !==
+                0;
+            return (asserted !== null &&
+                !admits(asserted) &&
+                !(asserted.isUnionType() && ts.constituentTypes(asserted).some(admits)));
+        };
         const mayBeOptional = (node) => {
             // `xs[i]!` is the explicit proven-present form. Its array read keeps
             // the established dense bounds trap and must not promote the enclosing
             // function/global ABI to `T | undefined`.
             if (explicitlyNonNull(node))
                 return false;
+            if (assertsDefined(node))
+                return false;
             const e = peel(node);
             if (isIndexedRead(e))
                 return true;
+            if (ts.isPropertyAccessExpression(e) && isRecordIndexPropertyRead(e))
+                return true;
             if (ts.isPropertyAccessExpression(e) && isOptionalProcessStreamProperty(this, e))
                 return true;
+            if (isOptionalProcessVersionsRead(this, e))
+                return true;
             if (ts.isPropertyAccessExpression(e) && isSettledIteratorValueRead(this, e))
                 return true;
             if (ts.isPropertyAccessExpression(e) && isOsConstantsSymbol(symbolOf(e.expression), this))
@@ -3394,7 +4244,7 @@ export class Lowerer {
             if (ts.isCallExpression(e) && this.runtimeOptionalReduceTypes.has(e))
                 return true;
             if (ts.isCallExpression(e) &&
-                e.arguments.length === 0 &&
+                e.arguments.nodes.length === 0 &&
                 ts.isPropertyAccessExpression(e.expression) &&
                 e.expression.name.text === "stringify" &&
                 this.isStdlibGlobal(e.expression.expression, "JSON"))
@@ -3532,12 +4382,12 @@ export class Lowerer {
          * exactly `T | undefined`: an assignment from a missing read stores the
          * undefined arm while the checker narrows later reads to `T`. */
         const optionalInstanceField = (symbol) => {
-            const decl = this.checker.valueDeclarationOf(symbol);
+            const decl = symbol.valueDeclaration;
             if (!decl || !ts.isPropertyDeclaration(decl) || !ts.isIdentifier(decl.name))
                 return false;
             if (ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Static)
                 return false;
-            const sf = decl.getSourceFile();
+            const sf = ts.getSourceFileOfNode(decl);
             if (isJsSourceFile(sf) || sf.isDeclarationFile)
                 return false;
             const declared = typeOrNull(decl.name);
@@ -3569,7 +4419,7 @@ export class Lowerer {
             // A fresh literal carries the fields its values can leave undefined.
             if (ts.isObjectLiteralExpression(e)) {
                 const out = spreadFieldsOf(e);
-                for (const prop of e.properties) {
+                for (const prop of e.properties.nodes) {
                     if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop))
                         continue;
                     const name = prop.name;
@@ -3607,7 +4457,7 @@ export class Lowerer {
          * the properties a later member writes explicitly. */
         const spreadFieldsOf = (object) => {
             const out = new Set();
-            for (const prop of object.properties) {
+            for (const prop of object.properties.nodes) {
                 if (ts.isSpreadAssignment(prop)) {
                     const fields = fieldsOfValue(prop.expression);
                     if (fields !== undefined)
@@ -3622,14 +4472,35 @@ export class Lowerer {
             return out;
         };
         const scanPattern = (name, init) => {
+            if (ts.isObjectBindingPattern(name)) {
+                // `const { 0: a, 1: b, length } = parts` reads positions like the
+                // equivalent array pattern: each may sit past the end.
+                // Regex match results keep their own pattern lowering.
+                const arrayType = this.mapTypeOf(this.typeOf(init));
+                const initType = this.checker.getNonNullableType(this.typeOf(init));
+                const initSymbol = initType.getAliasSymbol() ?? initType.getSymbol();
+                const matchResult = initSymbol !== undefined &&
+                    (ts.symbolName(initSymbol) === "RegExpExecArray" ||
+                        ts.symbolName(initSymbol) === "RegExpMatchArray");
+                if (arrayType?.kind !== "array" || matchResult)
+                    return scanRecordPattern(name, init);
+                const positions = name.elements.nodes.filter((el) => {
+                    const key = el.propertyName;
+                    return (key !== undefined && ts.isNumericLiteral(key) && /^(?:0|[1-9]\d{0,8})$/.test(key.text));
+                });
+                return scanPositions(positions, init, arrayType);
+            }
             if (!ts.isArrayBindingPattern(name))
                 return false;
             const sourceType = this.mapTypeOf(this.typeOf(init));
             if (sourceType?.kind !== "array")
                 return false;
+            return scanPositions(name.elements.nodes.filter((el) => !ts.isOmittedExpression(el)), init, sourceType);
+        };
+        const scanPositions = (elements, init, sourceType) => {
             let changed = false;
-            name.elements.forEach((el) => {
-                if (ts.isOmittedExpression(el) || el.name === undefined || el.dotDotDotToken)
+            elements.forEach((el) => {
+                if (el.name === undefined || el.dotDotDotToken)
                     return;
                 if (ts.isIdentifier(el.name)) {
                     const symbol = symbolOf(el.name);
@@ -3659,6 +4530,63 @@ export class Lowerer {
             });
             return changed;
         };
+        /** `const { a, b } = table` over an index-signature record: a name that
+         * is not a declared field reads the index signature and can be
+         * missing. */
+        const scanRecordPattern = (name, init, sourceType = this.mapTypeOf(this.typeOf(init))) => {
+            if (sourceType?.kind !== "record")
+                return false;
+            const shape = this.shapes.get(sourceType.shapeId);
+            if (!shape || shape.tuple)
+                return false;
+            const indexValue = shape.indexValue;
+            let changed = false;
+            for (const el of name.elements.nodes) {
+                // A nested pattern reads its element the same way
+                // (`const { limits: { [key]: limit } } = config`).
+                if (!el.dotDotDotToken && el.name !== undefined && ts.isObjectBindingPattern(el.name)) {
+                    if (scanRecordPattern(el.name, init, this.mapTypeOf(this.typeOf(el.name))))
+                        changed = true;
+                    continue;
+                }
+                if (!indexValue || indexValue.kind === "dyn")
+                    continue;
+                if (el.dotDotDotToken || el.initializer || !ts.isIdentifier(el.name))
+                    continue;
+                const key = el.propertyName ?? el.name;
+                // A computed key that folds to one name reads like that name; a
+                // runtime key reads the entry of a record with no declared fields
+                // (runtimeKeyPatternRead), which can be missing too.
+                const keyName = ts.isComputedPropertyName(key)
+                    ? this.foldedStringKeyOf(key.expression)
+                    : ts.isIdentifier(key) || ts.isStringLiteral(key) || ts.isNumericLiteral(key)
+                        ? key.text
+                        : undefined;
+                if (keyName === undefined)
+                    continue;
+                if (keyName === null ? shape.fields.length > 0 : shape.fields.some((f) => f.name === keyName))
+                    continue;
+                const symbol = symbolOf(el.name);
+                if (!symbol || optionalSymbols.has(symbol))
+                    continue;
+                const read = this.mapTypeOf(this.typeOf(el.name));
+                if (read?.kind === "union" && this.armTag(read.unionId, UNDEFINED_T) >= 0)
+                    continue;
+                const widened = this.withUndefinedArmOf(indexValue);
+                if (!widened)
+                    continue;
+                optionalSymbols.add(symbol);
+                provenance?.note("pattern-binding", el.name, init);
+                this.runtimeOptionalBindingTypes.set(symbol, widened);
+                const global = this.globalsBySymbol.get(symbol);
+                if (global) {
+                    global.type = widened;
+                    this.runtimeOptionalGlobals.add(global);
+                }
+                changed = true;
+            }
+            return changed;
+        };
         const hofCallbackIndices = (name, hasInitialValue) => {
             if (name === "reduce" || name === "reduceRight")
                 return hasInitialValue ? [1] : [0, 1];
@@ -3752,7 +4680,7 @@ export class Lowerer {
         };
         for (const [symbol, signature] of signatureBySymbol) {
             const declaration = functionDeclBySymbol.get(symbol);
-            if (!declaration || !isJsSourceFile(declaration.getSourceFile()))
+            if (!declaration || !isJsSourceFile(ts.getSourceFileOfNode(declaration)))
                 continue;
             const checked = this.checker.getSignatureFromDeclaration(declaration);
             const checkedReturn = checked ? this.checker.getReturnTypeOfSignature(checked) : null;
@@ -3780,7 +4708,7 @@ export class Lowerer {
                 for (const parameterIndex of parameterIndices) {
                     if (parameterIndex === undefined)
                         continue;
-                    const parameter = fn.parameters[parameterIndex];
+                    const parameter = fn.parameters.nodes[parameterIndex];
                     if (!parameter)
                         continue;
                     const symbol = ts.isIdentifier(parameter.name) ? symbolOf(parameter.name) : null;
@@ -3849,7 +4777,7 @@ export class Lowerer {
             if (this.genericFnsBySymbol.has(symbol))
                 return false;
             seen.add(symbol);
-            const declaration = this.checker.valueDeclarationOf(symbol);
+            const declaration = symbol.valueDeclaration;
             if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
                 if (promoteHofCallback(peel(declaration.initializer), parameterIndices, seen))
                     changed = true;
@@ -3904,7 +4832,9 @@ export class Lowerer {
                         owner.name)
                         ownerSymbol = symbolOf(owner.name);
                     const ownerSig = ownerSymbol ? signatureBySymbol.get(ownerSymbol) : undefined;
-                    const ownerIndex = ts.isFunctionLike(owner) ? owner.parameters.indexOf(declaration) : -1;
+                    const ownerIndex = ts.isFunctionLike(owner)
+                        ? owner.parameters.nodes.indexOf(declaration)
+                        : -1;
                     const slot = ownerIndex >= 0 ? ownerSig?.params[ownerIndex] : undefined;
                     if (slot && !typeEquals(slot.type, promoted)) {
                         slot.type = promoted;
@@ -3924,7 +4854,7 @@ export class Lowerer {
                 return false;
             let changed = false;
             for (const parameterIndex of parameterIndices) {
-                const parameter = fn.parameters[parameterIndex];
+                const parameter = fn.parameters.nodes[parameterIndex];
                 if (!parameter)
                     continue;
                 const checkerType = this.typeOf(parameter.name);
@@ -3962,7 +4892,7 @@ export class Lowerer {
             const fn = peel(callback);
             let param;
             if (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) {
-                const parameter = fn.parameters[index];
+                const parameter = fn.parameters.nodes[index];
                 if (!parameter?.type || parameter.dotDotDotToken)
                     return true;
                 const checkerType = this.typeOf(parameter.name);
@@ -3989,7 +4919,7 @@ export class Lowerer {
             const fn = functionDeclBySymbol.get(symbol);
             if (fn)
                 return bodyReturnsOptional(fn);
-            const decl = this.checker.valueDeclarationOf(symbol);
+            const decl = symbol.valueDeclaration;
             return (!!decl &&
                 ts.isVariableDeclaration(decl) &&
                 !!decl.initializer &&
@@ -4067,7 +4997,7 @@ export class Lowerer {
         };
         const ownership = new ArrayOwnership(sourceFiles, {
             symbolOf,
-            declarationOf: (symbol) => this.checker.valueDeclarationOf(symbol),
+            declarationOf: (symbol) => symbol.valueDeclaration,
             typeOf: typeOrNull,
             instanceAssignableTo: (owner, target) => panicSafe(() => this.checker.isTypeAssignableTo(this.checker.getTypeAtLocation(owner), target), true),
             isGlobal: (node, name) => this.isStdlibGlobal(node, name),
@@ -4088,7 +5018,7 @@ export class Lowerer {
                 // flow type such as `Array.isArray(x)`'s `any[]` only narrows it.
                 const e = peel(node);
                 const symbol = ts.isIdentifier(e) ? symbolOf(e) : null;
-                const declaration = symbol ? this.checker.valueDeclarationOf(symbol) : undefined;
+                const declaration = symbol ? symbol.valueDeclaration : undefined;
                 const declared = declaration &&
                     (ts.isVariableDeclaration(declaration) || ts.isParameter(declaration)) &&
                     ts.isIdentifier(declaration.name)
@@ -4144,14 +5074,14 @@ export class Lowerer {
                 else if (ts.isReturnStatement(node) && node.expression && dynamicValue(node.expression))
                     target(contextualOrNull(node.expression));
                 else if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
-                    for (const arg of node.arguments ?? [])
+                    for (const arg of node.arguments?.nodes ?? [])
                         if (!ts.isSpreadElement(arg) && dynamicValue(arg))
                             target(contextualOrNull(arg));
                 }
                 else if (ts.isPropertyAssignment(node) && dynamicValue(node.initializer))
                     target(contextualOrNull(node.initializer));
                 else if (ts.isArrayLiteralExpression(node)) {
-                    for (const element of node.elements)
+                    for (const element of node.elements.nodes)
                         if (!ts.isSpreadElement(element) &&
                             !ts.isOmittedExpression(element) &&
                             dynamicValue(element))
@@ -4261,6 +5191,7 @@ export class Lowerer {
             const nodes = [];
             ts.walkPreorder(sf, (node) => {
                 if (ts.isVariableDeclaration(node) ||
+                    (ts.isParameter(node) && ts.isObjectBindingPattern(node.name)) ||
                     ts.isBinaryExpression(node) ||
                     ts.isCallExpression(node) ||
                     ts.isNewExpression(node) ||
@@ -4282,6 +5213,12 @@ export class Lowerer {
                     changed = true;
                 if (ts.isForOfStatement(node))
                     presentLoops.set(node, !elementStates.loopMayYieldUndefined(node));
+                // A parameter pattern reads its argument like a declaration's
+                // pattern reads its initializer.
+                if (ts.isParameter(node) && ts.isObjectBindingPattern(node.name)) {
+                    if (scanRecordPattern(node.name, node, this.mapTypeOf(this.typeOf(node.name))))
+                        changed = true;
+                }
                 if (ts.isVariableDeclaration(node)) {
                     if (node.initializer) {
                         const result = optionalPrimitiveResultType(node.initializer);
@@ -4379,7 +5316,7 @@ export class Lowerer {
                         if (ts.isIdentifier(node.name) &&
                             ts.isObjectLiteralExpression(peel(node.initializer))) {
                             const object = peel(node.initializer);
-                            for (const prop of object.properties) {
+                            for (const prop of object.properties.nodes) {
                                 if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop))
                                     continue;
                                 const name = prop.name;
@@ -4412,7 +5349,7 @@ export class Lowerer {
                     const assertion = forwardedAssertion(node.right);
                     const symbol = assertion ? symbolOf(node.left) : null;
                     // Only a variable's storage is promoted (see the final pass).
-                    const declaration = symbol ? this.checker.valueDeclarationOf(symbol) : undefined;
+                    const declaration = symbol ? symbol.valueDeclaration : undefined;
                     if (assertion &&
                         symbol &&
                         declaration &&
@@ -4466,8 +5403,8 @@ export class Lowerer {
                     }
                 }
                 if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-                    const callbackIndices = hofCallbackIndices(node.expression.name.text, node.arguments.length >= 2);
-                    const callback = node.arguments[0];
+                    const callbackIndices = hofCallbackIndices(node.expression.name.text, node.arguments.nodes.length >= 2);
+                    const callback = node.arguments.nodes[0];
                     if (callbackIndices !== null && callback !== undefined && !ts.isSpreadElement(callback)) {
                         const receiverNode = node.expression.expression;
                         const receiverTs = this.typeOf(receiverNode);
@@ -4491,9 +5428,7 @@ export class Lowerer {
                         let nativeArrayReceiver = receiver?.kind === "array" || tuple;
                         if (nativeArrayReceiver && ts.isIdentifier(receiverNode)) {
                             const receiverSymbol = symbolOf(receiverNode);
-                            const declaration = receiverSymbol
-                                ? this.checker.valueDeclarationOf(receiverSymbol)
-                                : undefined;
+                            const declaration = receiverSymbol ? receiverSymbol.valueDeclaration : undefined;
                             if (declaration && ts.isVariableDeclaration(declaration)) {
                                 const declared = this.mapTypeOf(this.typeOf(declaration.name));
                                 if (declared?.kind !== "array" &&
@@ -4521,7 +5456,7 @@ export class Lowerer {
                             if (elementsPresent && reduce && retypeInlineCallback(callback, callbackIndices))
                                 changed = true;
                             if ((method === "reduce" || method === "reduceRight") &&
-                                ((!elementsPresent && node.arguments.length < 2) ||
+                                ((!elementsPresent && node.arguments.nodes.length < 2) ||
                                     callbackReturnsOptional(callback))) {
                                 if (promoteHofCallback(callback, [0, 1]))
                                     changed = true;
@@ -4547,20 +5482,20 @@ export class Lowerer {
                         // parameter, as for a callback the same value is passed as.
                         if (!ts.isIdentifier(node.expression) || reassigned.has(symbol))
                             return;
-                        const declaration = this.checker.valueDeclarationOf(symbol);
+                        const declaration = symbol.valueDeclaration;
                         const value = declaration && ts.isVariableDeclaration(declaration) && declaration.initializer
                             ? peel(declaration.initializer)
                             : null;
                         if (!value || !(ts.isArrowFunction(value) || ts.isFunctionExpression(value)))
                             return;
                         // Optional, defaulted and rest parameters keep their own ABI.
-                        if (value.parameters.some((parameter) => parameter.questionToken !== undefined ||
+                        if (value.parameters.nodes.some((parameter) => parameter.questionToken !== undefined ||
                             parameter.initializer !== undefined ||
                             parameter.dotDotDotToken !== undefined))
                             return;
-                        const indices = node.arguments.flatMap((arg, i) => !ts.isSpreadElement(arg) &&
-                            value.parameters[i] !== undefined &&
-                            !value.parameters[i].dotDotDotToken &&
+                        const indices = node.arguments.nodes.flatMap((arg, i) => !ts.isSpreadElement(arg) &&
+                            value.parameters.nodes[i] !== undefined &&
+                            !value.parameters.nodes[i].dotDotDotToken &&
                             mayBeOptional(arg)
                             ? [i]
                             : []);
@@ -4575,10 +5510,10 @@ export class Lowerer {
                     // agree on that value's representation.
                     const callee = functionDeclBySymbol.get(symbol);
                     if (callee &&
-                        isJsSourceFile(callee.getSourceFile()) &&
-                        !node.arguments.some(ts.isSpreadElement)) {
+                        isJsSourceFile(ts.getSourceFileOfNode(callee)) &&
+                        !node.arguments.nodes.some(ts.isSpreadElement)) {
                         for (let i = 0; i < sig.params.length; i++) {
-                            const arg = node.arguments[i];
+                            const arg = node.arguments.nodes[i];
                             if (arg &&
                                 (this.typeOf(arg).flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) === 0)
                                 continue;
@@ -4590,7 +5525,7 @@ export class Lowerer {
                                 if (typeEquals(shape.type, widened))
                                     continue;
                                 shape.type = widened;
-                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                const parameter = functionDeclBySymbol.get(target)?.parameters?.nodes[i];
                                 provenance?.note("parameter", parameter, node, "(omitted or undefined argument)");
                                 if (parameter) {
                                     for (const bound of boundIdentifiersOf(parameter.name)) {
@@ -4607,7 +5542,7 @@ export class Lowerer {
                         }
                     }
                     const restAt = sig.params.findIndex((shape) => shape.mode === "rest" || shape.mode === "dynRest" || shape.mode === "arguments");
-                    node.arguments.forEach((arg, argumentIndex) => {
+                    node.arguments.nodes.forEach((arg, argumentIndex) => {
                         const i = restAt >= 0 && argumentIndex >= restAt ? restAt : argumentIndex;
                         const shape = sig.params[i];
                         const callbackSlot = shape?.type;
@@ -4623,7 +5558,7 @@ export class Lowerer {
                             const fields = fieldsOfValue(arg);
                             for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
                                 const parameterShape = signatureBySymbol.get(target)?.params[i];
-                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                const parameter = functionDeclBySymbol.get(target)?.parameters?.nodes[i];
                                 if (!parameterShape || parameterShape.type.kind !== "record")
                                     continue;
                                 if (!parameter || !ts.isIdentifier(parameter.name))
@@ -4680,7 +5615,7 @@ export class Lowerer {
                                 if (typeEquals(rest.type, widened))
                                     continue;
                                 rest.type = widened;
-                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                const parameter = functionDeclBySymbol.get(target)?.parameters?.nodes[i];
                                 provenance?.note("rest-parameter", parameter, arg);
                                 if (parameter && ts.isIdentifier(parameter.name)) {
                                     const bound = symbolOf(parameter.name);
@@ -4707,7 +5642,7 @@ export class Lowerer {
                             optionalParams.set(target, set);
                             if (set.size !== before) {
                                 changed = true;
-                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                const parameter = functionDeclBySymbol.get(target)?.parameters?.nodes[i];
                                 provenance?.note("parameter", parameter, arg, target === symbol ? "" : "(override)");
                                 if (parameter) {
                                     for (const bound of boundIdentifiersOf(parameter.name)) {
@@ -4767,7 +5702,7 @@ export class Lowerer {
         // there, whatever its declared type.
         for (const symbol of earlyReadVarSymbols(this, sourceFiles)) {
             // Text codec bindings keep their own presence-checked storage.
-            const declaration = this.checker.valueDeclarationOf(symbol);
+            const declaration = symbol.valueDeclaration;
             const mapped = declaration && ts.isVariableDeclaration(declaration)
                 ? mappedOrNull(declaration.name)
                 : null;
@@ -4792,6 +5727,25 @@ export class Lowerer {
             for (const [symbol, decl] of functionDeclBySymbol)
                 if (scanReturns(symbol, decl))
                     changed = true;
+            const noteGenericReturn = (symbol, decl) => {
+                if (optionalReturns.has(symbol) || isJsSourceFile(ts.getSourceFileOfNode(decl)))
+                    return;
+                if (!returnsOf(decl).some(genericMayBeOptional))
+                    return;
+                optionalReturns.add(symbol);
+                this.runtimeOptionalGenericReturns.add(decl);
+                provenance?.note("return", decl.name ?? decl, decl);
+                changed = true;
+            };
+            for (const [symbol, info] of this.genericFnsBySymbol)
+                noteGenericReturn(symbol, info.decl);
+            // Generic methods and methods of a generic class collect with their
+            // class, after this analysis; their result admits undefined there.
+            for (const method of genericClassMethods) {
+                const symbol = method.name ? symbolOf(method.name) : null;
+                if (symbol)
+                    noteGenericReturn(symbol, method);
+            }
             for (const fn of tsLambdas) {
                 // An annotated return is the author's contract, as for parameters,
                 // except that a var read before its first store is undefined
@@ -4899,7 +5853,7 @@ export class Lowerer {
         for (const [symbol, params] of optionalParams) {
             const decl = functionDeclBySymbol.get(symbol);
             for (const index of [...params]) {
-                const name = decl?.parameters[index]?.name;
+                const name = decl?.parameters?.nodes[index]?.name;
                 const param = name && ts.isIdentifier(name) ? symbolOf(name) : null;
                 if (param && nanCoded.nanCodedBinding(param))
                     params.delete(index);
@@ -4944,20 +5898,52 @@ export class Lowerer {
             addClassFields(recordFlows.bindingClass(symbol), fields);
         for (const [symbol, fields] of returnFields)
             addClassFields(recordFlows.returnClass(symbol), fields);
+        // A record field that flows into other slots (`fill(args, state.parsed)`)
+        // widens with its owner's class: every member takes the field's widened
+        // layout, so the field and the slots it reaches share one record.
+        const nestedFields = new Map();
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const { owner, name, classId } of recordFlows.fields()) {
+                if (nestedFields.get(owner)?.has(name))
+                    continue;
+                if (!(classFields.has(classId) || nestedFields.has(classId)))
+                    continue;
+                if (!recordFlows.closed(classId))
+                    continue;
+                const byName = nestedFields.get(owner) ?? new Map();
+                byName.set(name, classId);
+                nestedFields.set(owner, byName);
+                changed = true;
+            }
+        }
         const settledFields = (id, own) => id === null
             ? own
-            : classFields.has(id) && recordFlows.closed(id)
-                ? classFields.get(id)
+            : (classFields.has(id) || nestedFields.has(id)) && recordFlows.closed(id)
+                ? (classFields.get(id) ?? new Set())
                 : undefined;
-        const widenRecordFields = (type, fields) => {
+        const widenRecordFields = (type, fields, id = null, seen = new Set()) => {
             let promoted = type;
+            const fieldOf = (name) => promoted.kind === "record"
+                ? this.shapes.get(promoted.shapeId)?.fields.find((f) => f.name === name)
+                : undefined;
             for (const field of fields) {
-                const source = promoted.kind === "record"
-                    ? this.shapes.get(promoted.shapeId)?.fields.find((f) => f.name === field)
-                    : undefined;
+                const source = fieldOf(field);
                 if (source)
                     promoted = this.runtimeOptionalRecordField(promoted, field, addUndefined(source.type));
             }
+            if (id === null || seen.has(id))
+                return promoted;
+            const nested = nestedFields.get(id);
+            if (!nested)
+                return promoted;
+            for (const [field, inner] of nested) {
+                const source = fieldOf(field);
+                if (source?.type.kind !== "record")
+                    continue;
+                const widened = widenRecordFields(source.type, classFields.get(inner) ?? new Set(), inner, new Set([...seen, id]));
+                promoted = this.runtimeOptionalRecordField(promoted, field, widened);
+            }
             return promoted;
         };
         for (const [symbol, id] of recordFlows.bindings())
@@ -4973,10 +5959,11 @@ export class Lowerer {
             const shape = signatureBySymbol.get(target)?.params[index];
             if (!shape || shape.type.kind !== "record")
                 continue;
-            const fields = settledFields(recordFlows.bindingClass(bound), optionalFields.get(bound));
+            const id = recordFlows.bindingClass(bound);
+            const fields = settledFields(id, optionalFields.get(bound));
             if (!fields)
                 continue;
-            const promoted = widenRecordFields(shape.type, fields);
+            const promoted = widenRecordFields(shape.type, fields, id);
             if (typeEquals(promoted, shape.type))
                 continue;
             shape.type = promoted;
@@ -4986,7 +5973,7 @@ export class Lowerer {
             const id = recordFlows.returnClass(symbol);
             const fields = id === null ? undefined : settledFields(id, undefined);
             if (fields && sig.returnType.kind === "record") {
-                const next = widenRecordFields(sig.returnType, fields);
+                const next = widenRecordFields(sig.returnType, fields, id);
                 sig.returnType = next;
                 if (sig.top)
                     sig.top.returnType = next;
@@ -5028,7 +6015,7 @@ export class Lowerer {
         for (const [declaration, global] of this.globalsByDeclNode) {
             if (global.type.kind !== "func" ||
                 !ts.isBinaryExpression(declaration) ||
-                !isJsSourceFile(declaration.getSourceFile()))
+                !isJsSourceFile(ts.getSourceFileOfNode(declaration)))
                 continue;
             const value = peel(declaration.right);
             if (!ts.isFunctionExpression(value) && !ts.isArrowFunction(value))
@@ -5077,7 +6064,8 @@ export class Lowerer {
                             global.type = promoted;
                     }
                 }
-                const fields = settledFields(recordFlows.bindingClass(symbol), optionalFields.get(symbol));
+                const flowClass = recordFlows.bindingClass(symbol);
+                const fields = settledFields(flowClass, optionalFields.get(symbol));
                 if (!dynamicObjectEntryRows.has(symbol) && !optionalSymbols.has(symbol) && !fields)
                     return;
                 const current = this.mapTypeOf(this.typeOf(node.name));
@@ -5097,7 +6085,7 @@ export class Lowerer {
                     }
                 }
                 if (fields && promoted.kind === "record")
-                    promoted = widenRecordFields(promoted, fields);
+                    promoted = widenRecordFields(promoted, fields, flowClass);
                 if (!typeEquals(promoted, current)) {
                     this.runtimeOptionalBindingTypes.set(symbol, promoted);
                     const global = ts.isIdentifier(node.name)
@@ -5130,9 +6118,9 @@ export class Lowerer {
                     continue;
                 const symbol = callableSymbolOf(node.expression);
                 const sig = symbol ? signatureBySymbol.get(symbol) : undefined;
-                if (!sig || node.arguments.some(ts.isSpreadElement))
+                if (!sig || node.arguments.nodes.some(ts.isSpreadElement))
                     continue;
-                node.arguments.forEach((arg, i) => {
+                node.arguments.nodes.forEach((arg, i) => {
                     let e = arg;
                     while (ts.isParenthesizedExpression(e))
                         e = e.expression;
@@ -5162,7 +6150,12 @@ export class Lowerer {
                 this.checker.prefetchSourceFile(fp.sf);
         }
         this.collectProgram(parts);
-        this.analyzeRuntimeOptionalArrayReads(parts);
+        this.speculativeTypeQueries(() => {
+            extendAssertedRecordMembers(this, parts.map((fp) => fp.sf));
+            this.analyzeRuntimeOptionalArrayReads(parts);
+            this.analyzeDateJsonResults(parts);
+            this.analyzeGuardedRecordReadGlobals(parts);
+        });
         // Decorated classes analyze AFTER the whole collection pass: a
         // decorator's return type may name a subclass declared below the
         // class, and reference lowering needs each class's rebindability
@@ -5287,6 +6280,7 @@ export class Lowerer {
         // implicit-any instances lowered eagerly at their first call sites.
         functions.push(...this.liftedFns);
         functions.push(...this.implicitFns);
+        functions.push(...runtimeClassConstructs(this, functions));
         if (this.remainder) {
             // Deferred collection diagnostics nothing flushed — declarations no
             // reference ever made relevant. They belong to the unreached group
@@ -5314,7 +6308,10 @@ export class Lowerer {
         if (this.diags.length === 0)
             fuseArrayPipelines(this, functions);
         finalizeClassMethodValues(this, functions);
+        finalizePrivateBrands(this, functions);
         trackClassFieldCreation(this, functions);
+        guardClassAttributeWrites(this, functions);
+        applyHandleProperties(this, functions);
         // Globals typed by a class that never REGISTERED (a JS class whose
         // collection fenced — Symbol-keyed fields, an unsupported base): the
         // declaration statement and every use compiled to runtime fences, but
@@ -5402,10 +6399,11 @@ export class Lowerer {
         // slots), uniformly across params/locals/globals/fields/body types so
         // every producer and consumer agrees. Programs with no unregistered
         // reference are untouched — byte-stability holds.
+        checkRequireBindingAccesses(this, functions);
         const module = this.diags.length > 0
             ? null
             : {
-                irVersion: 16,
+                irVersion: 17,
                 sourceFile: this.entry.fileName,
                 functions,
                 classes: artifacts.classes,
@@ -5415,6 +6413,9 @@ export class Lowerer {
                 entry: ENTRY_NAME,
                 ...(this.usesWorkers ? { workers: true } : {}),
                 ...(this.usesLifetimeRegions ? { lifetimeRegions: true } : {}),
+                ...(this.threadSlotKeys.size > 0
+                    ? { threadSlotKeys: [...this.threadSlotKeys].sort() }
+                    : {}),
                 ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
             };
@@ -5422,11 +6423,23 @@ export class Lowerer {
             sanitizeUnregisteredClassTypes(module, (name) => this.classes.has(name));
         if (module)
             checkCycleBindingAccesses(this, module);
+        // Execution tiers from the final bodies (ir/tiers.ts). Assigned with or
+        // without a module: coverage reports the dynamic tier of programs that
+        // still have blockers.
+        this.dynamicFunctions = assignLegacyTiers(functions);
+        if (this.dynamicFunctions.length > 0)
+            this.dynamicBodies = functions.filter((fn) => fn.tier === "dynamic");
+        // Dynamic-tier functions compute with jsval values (ir/jsval.ts). The
+        // rewrite keeps every dynamic operation dynamic (each dyn operator
+        // becomes its js twin), so coverage's dynamic statements are unchanged.
+        if (module && this.dynamicFunctions.length > 0)
+            promoteJsvals(module);
         return {
             module,
             diagnostics: this.diags,
             runtimeFences: this.runtimeFences,
             stats: this.stats,
+            ...(this.dynamicFunctions.length > 0 ? { dynamicFunctions: this.dynamicFunctions } : {}),
             ...(this.statsByFile.size > 0 ? { statsByFile: this.statsByFile } : {}),
             ...(this.provenanceElided.length > 0 ? { provenanceElided: this.provenanceElided } : {}),
         };
@@ -5497,7 +6510,7 @@ export class Lowerer {
             return;
         this.stats.statementsTotal += n;
         this.stats.statementsFailed += n;
-        const file = decl.getSourceFile().fileName;
+        const file = ts.getSourceFileOfNode(decl).fileName;
         for (let i = 0; i < n; i++) {
             this.bumpFileStat(file, "total");
             this.bumpFileStat(file, "failed");
@@ -5539,7 +6552,7 @@ export class Lowerer {
         // declarations before collectProgram visits their signatures.
         this.checker.prefetchCollectionTypes(parts.flatMap((fp) => fp.fnDecls
             .filter((decl) => decl.body !== undefined && decl.typeParameters === undefined)
-            .flatMap((decl) => decl.parameters.flatMap((param) => (param.initializer ? [param.initializer] : [])))));
+            .flatMap((decl) => decl.parameters.nodes.flatMap((param) => param.initializer ? [param.initializer] : []))));
         // JavaScript class shapes are partly declared by constructor-body
         // assignments. Batch those collection-time queries across declarations
         // before collectProgram visits them one by one; reached body lowering
@@ -5550,7 +6563,12 @@ export class Lowerer {
             collectionEdges.add(name);
         };
         this.collectProgram(parts);
-        this.analyzeRuntimeOptionalArrayReads(parts);
+        this.speculativeTypeQueries(() => {
+            extendAssertedRecordMembers(this, parts.map((fp) => fp.sf));
+            this.analyzeRuntimeOptionalArrayReads(parts);
+            this.analyzeDateJsonResults(parts);
+            this.analyzeGuardedRecordReadGlobals(parts);
+        });
         // Decorated classes analyze post-collection here too: the %init seeds
         // lower the decoration calls, whose edges (decorator bodies, construct
         // thunks) reachable emit must see.
@@ -5563,8 +6581,8 @@ export class Lowerer {
         // (qualified declaration names).
         const units = new Map();
         const bodyRoots = (...roots) => roots.filter((root) => root !== undefined && root !== null);
-        const functionRoots = (decl) => bodyRoots(...decl.parameters.map((param) => param.initializer), decl.body);
-        const classCtorRoots = (info) => bodyRoots(...(info.ctor?.parameters ?? []).map((param) => param.initializer), info.ctor?.body, ...info.fieldOrder.map((field) => field.initializer));
+        const functionRoots = (decl) => bodyRoots(...decl.parameters.nodes.map((param) => param.initializer), decl.body);
+        const classCtorRoots = (info) => bodyRoots(...(info.ctor?.parameters?.nodes ?? []).map((param) => param.initializer), info.ctor?.body, ...info.fieldOrder.map((field) => field.initializer));
         const classMemberRoots = (info) => {
             const roots = classCtorRoots(info);
             for (const { member } of this.classMethodMembers(info))
@@ -5599,7 +6617,7 @@ export class Lowerer {
         for (const info of this.classes.values()) {
             if (info.builtinError)
                 continue; // runtime-provided; nothing lowers
-            if (info.lifetimeRegion || info.internTable)
+            if (info.lifetimeRegion || info.internTable || info.threadSlots)
                 continue; // synthesized with the class
             // Generic-class INSTANTIATIONS (and mixin instantiations) are
             // demand-driven, not units: their members lower unconditionally in
@@ -5906,6 +6924,13 @@ export class Lowerer {
         this.shapes.settleDeclaredOrderPriorities();
         for (const finalize of this.shapeOrderMetadataFinalizers)
             finalize();
+        applyKeyOrderWitnesses(this, [
+            ...orderedUnits,
+            ...initFunctions,
+            ...instanceFunctions,
+            ...this.liftedFns,
+            ...this.implicitFns,
+        ]);
         for (const finalize of this.shapeOrderHelperFinalizers)
             finalize();
         const functions = [
@@ -5916,6 +6941,7 @@ export class Lowerer {
             ...this.liftedFns,
             ...this.implicitFns,
         ];
+        functions.push(...runtimeClassConstructs(this, functions));
         if (this.regexGroupResults)
             for (const fn of functions)
                 foldRegexSpanReads(this, fn);
@@ -5986,23 +7012,8 @@ export class Lowerer {
             return null;
         }
         this.runtimeFences.push(...captured);
-        const first = captured[0];
+        const fence = this.runtimeFenceStmt(captured[0], node, target.fallback, target.bareMessage);
         const loc = locOf(node);
-        const code = first?.code ?? target.fallback.code;
-        const baseMessage = first?.message ?? target.fallback.message;
-        const messageLoc = first?.loc ?? loc;
-        const source = first
-            ? (this.program.getSourceFile(messageLoc.file) ?? node.getSourceFile())
-            : node.getSourceFile();
-        const pos = ts.getLineAndCharacterOfPosition(source, messageLoc.start);
-        const fence = {
-            kind: "runtimeFence",
-            code,
-            message: target.bareMessage
-                ? baseMessage
-                : `${baseMessage} [${code} at ${messageLoc.file}:${pos.line + 1}]`,
-            loc,
-        };
         if (target.kind === "statement")
             return fence;
         const params = target.params ?? [];
@@ -6031,6 +7042,46 @@ export class Lowerer {
         this.liftedFns.push(fn);
         return { kind: "closure", fnName: fn.name, captures: [], type: target.type, loc };
     }
+    /** The runtimeFence statement that throws `first`'s message (or the
+     * fallback's) at `node`. */
+    runtimeFenceStmt(first, node, fallback, bareMessage = false) {
+        const loc = locOf(node);
+        const code = first?.code ?? fallback?.code ?? "SC1090";
+        const baseMessage = first?.message ??
+            fallback?.message ??
+            "this statement uses a construct with no static lowering";
+        const messageLoc = first?.loc ?? loc;
+        const source = first
+            ? (this.program.getSourceFile(messageLoc.file) ?? ts.getSourceFileOfNode(node))
+            : ts.getSourceFileOfNode(node);
+        const pos = ts.getLineAndCharacterOfPosition(source, messageLoc.start);
+        return {
+            kind: "runtimeFence",
+            code,
+            message: bareMessage
+                ? baseMessage
+                : `${baseMessage} [${code} at ${messageLoc.file}:${pos.line + 1}]`,
+            loc,
+        };
+    }
+    /** The current length of the capture buffer (diagSink), or 0 without one:
+     * the mark capturedRuntimeFence reads the refusal from. */
+    diagSinkMark() {
+        return this.diagSink?.length ?? 0;
+    }
+    /** 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, node) {
+        if (this.diagSink === null)
+            return null;
+        return this.runtimeFenceStmt(this.diagSink[sinkMark], node, undefined);
+    }
     /** 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. */
@@ -6100,9 +7151,9 @@ export class Lowerer {
         // fetch values map earlier to checked-dynamic handles and do not reach
         // here; constructor objects such as Headers still can.
         if (typeSym &&
-            FETCH_AMBIENT_TYPES.includes(typeSym.name) &&
+            FETCH_AMBIENT_TYPES.includes(ts.symbolName(typeSym)) &&
             this.isStdlibSymbol(typeSym)) {
-            this.pushDiag(unsupportedNativeApiDiag(`a value of type '${typeSym.name}'`, locOf(node)));
+            this.pushDiag(unsupportedNativeApiDiag(`a value of type '${ts.symbolName(typeSym)}'`, locOf(node)));
             throw new PoisonError();
         }
         // ENUM OBJECTS (`typeof e` — a numeric enum's type carries the
@@ -6112,7 +7163,7 @@ export class Lowerer {
         // as the per-site identifier fence — never the index-signature
         // recitation.
         if (typeSym && (typeSym.flags & ts.SymbolFlags.Enum) !== 0) {
-            this.pushDiag(unsupportedDiag("SC1090", locOf(node), `enum objects as values ('${typeSym.name}' — member reads like '${typeSym.name}.X' compile to constants; the object itself has no runtime representation)`));
+            this.pushDiag(unsupportedDiag("SC1090", locOf(node), `enum objects as values ('${ts.symbolName(typeSym)}' — member reads like '${ts.symbolName(typeSym)}.X' compile to constants; the object itself has no runtime representation)`));
             throw new PoisonError();
         }
         // Would-be records with INDEX SIGNATURES (`Record<string, T>`,
@@ -6134,10 +7185,8 @@ export class Lowerer {
             // (the value type, the key domain) the fences below tell better.
             const ownSym = widened.getSymbol();
             if (ownSym &&
-                this.checker
-                    .declarationsOf(ownSym)
-                    .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-                    this.isStdlibFile(d.getSourceFile()))) {
+                ownSym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+                    this.isStdlibFile(ts.getSourceFileOfNode(d)))) {
                 this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node)));
                 throw new PoisonError();
             }
@@ -6172,10 +7221,8 @@ export class Lowerer {
         // tell — rather than an overload/record claim no user can act on.
         const stdlibOwnSym = widened.getSymbol();
         const stdlibNominal = stdlibOwnSym !== undefined &&
-            this.checker
-                .declarationsOf(stdlibOwnSym)
-                .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-                this.isStdlibFile(d.getSourceFile()));
+            stdlibOwnSym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+                this.isStdlibFile(ts.getSourceFileOfNode(d)));
         // OVERLOADED call signatures (SC2007) — after the generic branch, so a
         // generic overload set keeps the monomorphization story: a value of a
         // multi-signature type has no single compiled signature to hold.
@@ -6227,7 +7274,7 @@ export class Lowerer {
                 TextEncoder: "TextEncoder instances support encode(string) and encode(); other codec operations require a dedicated lowering",
                 TextDecoder: "TextDecoder instances support recognized labels, fatal/ignoreBOM option literals, and streaming UTF-8/UTF-16/single-byte decode; runtime option objects remain unsupported",
             };
-            this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node), typeHints[stdlibOwnSym?.name ?? ""]));
+            this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node), typeHints[ts.symbolNameOf(stdlibOwnSym) ?? ""]));
             throw new PoisonError();
         }
         // USER record shapes blocked by ONE member (SC2009's record arm):
@@ -6254,7 +7301,9 @@ export class Lowerer {
         return stdlibMemberFence(this, access);
     }
     fenceStaticResponseMember(access, use) {
-        return fenceStaticResponseMember(this, access, use) ?? fenceStaticBlobMember(this, access, use);
+        return (fenceStaticResponseMember(this, access, use) ??
+            fenceStaticBlobMember(this, access, use) ??
+            fenceWebCryptoMember(this, access, use));
     }
     fenceUnsupportedFetchConstructorMember(access) {
         return fenceUnsupportedFetchConstructorMember(this, access);
@@ -6275,7 +7324,7 @@ export class Lowerer {
         return fenceStaticReadableStreamMember(this, access, use);
     }
     typeOf(node) {
-        if (ts.isPropertyAccessExpression(node) && isJsSourceFile(node.getSourceFile())) {
+        if (ts.isPropertyAccessExpression(node) && isJsSourceFile(ts.getSourceFileOfNode(node))) {
             const receiver = node.expression.kind === ts.SyntaxKind.ThisKeyword && this.fnStack.length > 0
                 ? this.resolveThis()?.type
                 : this.mapTypeOf(this.checker.getTypeAtLocation(node.expression));
@@ -6290,11 +7339,25 @@ export class Lowerer {
                 return this.checker.getUnknownType();
             }
         }
+        // A symbol-keyed field read through a CommonJS key-table key reads as
+        // the field's layout type (tableKeyFieldType).
+        if (ts.isElementAccessExpression(node) && isJsSourceFile(ts.getSourceFileOfNode(node))) {
+            const field = tableKeyFieldType(this, node);
+            if (field) {
+                if (field.kind === "f64")
+                    return this.checker.getNumberType();
+                if (field.kind === "string")
+                    return this.checker.getStringType();
+                if (field.kind === "bool")
+                    return this.checker.getBooleanType();
+                return this.checker.getUnknownType();
+            }
+        }
         // A checked JS method receives its actual call-site receiver. Its
         // declaration's inferred class type must not turn property reads back
         // into native field loads when the method is borrowed by another object.
         if (node.kind === ts.SyntaxKind.ThisKeyword &&
-            isJsSourceFile(node.getSourceFile()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(node)) &&
             this.fnStack.length > 0 &&
             this.resolveThis()?.type.kind === "dyn")
             return this.checker.getUnknownType();
@@ -6355,7 +7418,7 @@ export class Lowerer {
                     // JSDoc and initializer inference are declaration types, not flow
                     // proofs. A checked specialization must not reinstate those
                     // stale layouts (mutable/null slots and heterogeneous JS arrays).
-                    const declaration = sym && this.checker.valueDeclarationOf(sym);
+                    const declaration = sym && sym.valueDeclaration;
                     const declared = declaration && ts.isParameter(declaration)
                         ? this.mapTypeOf(this.checker.getTypeAtLocation(declaration.name))
                         : null;
@@ -6392,6 +7455,14 @@ export class Lowerer {
             ? (jsArgumentsFunctionType(this, t) ?? mapped)
             : mapped;
     }
+    /** 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) {
+        if (isOverloadedCallableMemberType(t, this.checker))
+            return erasedOverloadMemberType(t, this.typeCtx) ?? null;
+        return this.mapTypeOf(t);
+    }
     /** 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
@@ -6494,7 +7565,15 @@ export class Lowerer {
                 return ts.constituentTypes(part).every(visit);
             return false;
         };
-        return visit(t);
+        // A union typescript-go cannot describe is not proven an array.
+        try {
+            return visit(t);
+        }
+        catch (e) {
+            if (ts.isUnreadableConstituentsPanic(e))
+                return false;
+            throw e;
+        }
     }
     /** The lowered static array/tuple value behind checkerAnyArray's
      * synthetic `any[]` spelling. Array.isArray can leave readonly tuple
@@ -6532,7 +7611,7 @@ export class Lowerer {
         // JS inference can leave mutable fields, accessor parameters and
         // locals at null/undefined despite later writes. Keep mutable native
         // storage instead of a slot restricted to the initializer's unit value.
-        if (isJsSourceFile(node.getSourceFile()) &&
+        if (isJsSourceFile(ts.getSourceFileOfNode(node)) &&
             (t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0)
             return DYN;
         // A never-tainted JS type (neverTaintedJsType) maps — never rides as
@@ -6543,6 +7622,9 @@ export class Lowerer {
             const argumentsType = jsArgumentsFunctionType(this, t);
             if (argumentsType !== null)
                 return argumentsType;
+            const localClass = genericLocalClassBinding(this, node);
+            if (localClass !== null)
+                return localClass;
             // The checked-dynamic declaration fallback (dynFallbackType): a
             // JAVASCRIPT binding of any inference residue, or a TypeScript
             // binding of genuine checker-`any`, becomes the checked-dynamic
@@ -6570,6 +7652,13 @@ export class Lowerer {
     requireExactShape(node, actual, expected) {
         if (typeEquals(actual, expected))
             return;
+        if (!this.generalNodeStreams && needsGeneralNodeStreams(this, actual, expected)) {
+            this.requiresGeneralNodeStreams = true;
+            // An untyped value into a stream slot also needs the checked-dynamic
+            // slots (dyn-streams.ts).
+            if (actual.kind === "dyn")
+                this.requiresDynNodeStreams = true;
+        }
         // dyn mismatches first. A dyn ('unknown') value flowing into a typed
         // slot needs a CHECKED cast — the hint points at `as <type>`; tsc
         // usually rejects this before we do, so the fence is mostly defensive.
@@ -6725,6 +7814,15 @@ export class Lowerer {
      * else (including a DIFFERENT union) is left for requireExactShape, which
      * rejects union mismatches with SC2003. */
     coerceToExpected(expr, expected) {
+        // A comma expression ending in a unit literal (`return log(), null`):
+        // its effects run first, unchanged, and the unit value takes the
+        // destination's representation (a bare unit literal has none).
+        if (expr.kind === "seqExpr" &&
+            expr.result.kind === "unitLit" &&
+            !typeEquals(expr.type, expected)) {
+            const result = this.coerceToExpected(expr.result, expected);
+            return { ...expr, result, type: result.type };
+        }
         // A destination that holds undefined takes an unassigned deferred-init
         // field's slot as is (Node passes the undefined along).
         if (expected.kind === "union" && this.armTag(expected.unionId, UNDEFINED_T) >= 0) {
@@ -6734,6 +7832,10 @@ export class Lowerer {
         }
         if (expr.type.kind === "void" && expected.kind !== "void" && this.neverValued.has(expr))
             return this.divergentValue(expr, expected);
+        // process.stdout/stderr into a general Writable slot (general-streams.ts).
+        const stdioStream = stdioIntoGeneralStream(this, expr, expected);
+        if (stdioStream)
+            return this.coerceToExpected(stdioStream, expected);
         // Iterator-typed slots: native iterators and differently typed
         // generators step through an adapter generator.
         if (expected.kind === "generator" && !typeEquals(expr.type, expected)) {
@@ -6754,6 +7856,16 @@ export class Lowerer {
         // undefined/null literals store the dyn unit values. Types outside the
         // dyn's domain (bytes, classes, Maps, ...) fall through to
         // requireExactShape's SC1101 fence.
+        // A promise entering a maybe-promise union whose promise arm has a
+        // wider payload (`Promise<R>` into `Promise<R | void> | R | void`)
+        // takes the payload widening below first, then wraps into that arm.
+        if (expected.kind === "union" && expr.type.kind === "promise") {
+            const mp = maybePromiseUnionOf(this, expected);
+            if (mp &&
+                !typeEquals(mp.promise, expr.type) &&
+                this.promisePayloadWidens(expr.type, mp.promise))
+                expr = this.coerceToExpected(expr, mp.promise);
+        }
         // Promise payloads may widen at a checked return boundary, including
         // arrays inferred as tuple results by Promise.all. Keep both payload
         // ABIs explicit: box settlement, then validate the destination payload.
@@ -6803,6 +7915,37 @@ export class Lowerer {
                     loc: expr.loc,
                 };
             }
+            // A runtime-provided class value has no checked-dynamic form that
+            // inspects as Node's does (`[Function: EventEmitter] { ... }`).
+            // JavaScript sources already read EventEmitter and the stream
+            // classes as the runtime's untyped constructors (builtin-class-dyn.ts),
+            // so one of those classes turning untyped there becomes the same
+            // constructor. `require("events")` is the EventEmitter class itself,
+            // so its module binding is too (`ReleaseEmitter = EventEmitter` over
+            // `const EventEmitter = require("events")`).
+            if (expr.type.kind === "moduleNs" &&
+                expr.type.moduleId === "builtin:events" &&
+                isJsSourceFileName(expr.loc.file)) {
+                const value = builtinClassValue(0, expr.loc);
+                if (expr.kind === "moduleNsRef")
+                    return value;
+                return {
+                    kind: "seqExpr",
+                    stmts: [{ kind: "exprStmt", expr, loc: expr.loc }],
+                    result: value,
+                    type: DYN,
+                    loc: expr.loc,
+                };
+            }
+            if (expr.type.kind === "classval" && this.classes.get(expr.type.className)?.def.runtime) {
+                // Only the class itself: a slot of the class's type may hold a
+                // program subclass, which this constructor would misidentify.
+                const kind = builtinClassKind(expr.type.className);
+                if (kind !== null && expr.kind === "classRef" && isJsSourceFileName(expr.loc.file))
+                    return builtinClassValue(kind, expr.loc);
+                this.pushDiag(unsupportedDiag("SC1090", expr.loc, `a runtime-provided class value ('${expr.type.className.slice(1)}') as an untyped value`));
+                throw new PoisonError();
+            }
             if (expr.kind === "unitLit" || this.dynConvertible(expr.type)) {
                 // Records and arrays keep their identity as untyped values, including
                 // when they arrive through a union, so `unknown` views, weak
@@ -6816,12 +7959,16 @@ export class Lowerer {
                 const liveRef = liveReference(expr.type) ||
                     (expr.type.kind === "union" &&
                         (this.unions.get(expr.type.unionId)?.arms.some(liveReference) ?? false));
+                // A builtin function's adapter boxes under the builtin's name, the
+                // name Node's function carries (`[Function: randomUUID]`).
+                const builtinName = expr.kind === "closure" ? this.builtinCallableValueNames.get(expr.fnName) : undefined;
                 return {
                     kind: "dynFrom",
                     value: expr,
                     type: DYN,
                     loc: expr.loc,
                     ...(liveRef ? { liveRef: true } : {}),
+                    ...(builtinName !== undefined ? { fnName: builtinName } : {}),
                 };
             }
             return expr;
@@ -6858,6 +8005,17 @@ export class Lowerer {
             const funcOk = expected.kind === "func" &&
                 canAdaptDynFuncTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id));
             const handleOk = DYN_HANDLE_KINDS.has(expected.kind);
+            noteUntypedStreamFlow(this, expected);
+            // `[EventEmitter]` in JavaScript builds an untyped array of the
+            // untyped constructor, which a typed array of the class cannot
+            // hold: no class check admits that constructor.
+            if (expr.kind === "dynArrLit" &&
+                expected.kind === "array" &&
+                expected.elem.kind === "classval" &&
+                expr.elems.some((elem) => elem.kind === "libCall" && elem.fn === "dyn.builtinClass")) {
+                this.pushDiag(unsupportedDiag("SC1090", expr.loc, `holding runtime-provided class values ('${expected.elem.className.slice(1)}') in a typed array`));
+                throw new PoisonError();
+            }
             if (canDynCheckTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id)) ||
                 undefArmedOk ||
                 bytesOk ||
@@ -6990,6 +8148,7 @@ export class Lowerer {
             // and no completion target is meaningful — the exact-shape fence
             // downstream names the class-value flow instead.
             if (sub && sup && !sup.generic && this.ctorAbiEquals(sub, sup)) {
+                defineClassValueConstruct(this, sup);
                 return { kind: "upcast", value: expr, type: expected, loc: expr.loc };
             }
         }
@@ -7026,6 +8185,11 @@ export class Lowerer {
                     return this.applyWidthLift(lift, narrowed, expected, expr.loc);
                 }
             }
+            if (expr.type.kind === "union" && expected.kind === "record") {
+                const lifted = unionArmsWidthLift(this, expr, expected);
+                if (lifted)
+                    return lifted;
+            }
             if (!typeEquals(expr.type, expected)) {
                 const w = this.widthCoerce(expr, expected);
                 if (w)
@@ -7110,6 +8274,7 @@ export class Lowerer {
                     if (baseTag >= 0) {
                         if (!sub || !this.ctorAbiEquals(sub, c))
                             break;
+                        defineClassValueConstruct(this, c);
                         const widened = {
                             kind: "upcast",
                             value: expr,
@@ -7266,6 +8431,9 @@ export class Lowerer {
     recordUnionWrapHelper(source, toId, loc) {
         return recordUnionWrapHelper(this, source, toId, loc);
     }
+    recordUnionRouteHelper(source, toId, loc) {
+        return recordUnionRouteHelper(this, source, toId, loc);
+    }
     unionRetagHelper(fromId, toId, loc, trappable) {
         return unionRetagHelper(this, fromId, toId, loc, trappable);
     }
@@ -7284,6 +8452,7 @@ export class Lowerer {
      * lowering goes through here (via lowerExprExpecting) or calls this
      * directly when the expression was already lowered. */
     coerceInto(node, expr, expected) {
+        refuseInferredCallbackDrops(this, node, expr.type, expected);
         // A union destination can accept the binding's tagged storage directly.
         // The checker's single-arm flow type can be stale after a callback writes
         // the binding. Extracting that arm and wrapping it again would discard the
@@ -7301,9 +8470,16 @@ export class Lowerer {
         // initial contextual layout was chosen. Its known discriminator still
         // selects the destination arm; validate that payload before wrapping.
         // Work with the already lowered value so property effects run once.
+        // A type assertion keeps the literal's own record layout, which can
+        // equal another arm's layout (`{ kind: "return", value, loc } as Stmt`
+        // when a `throw` arm has the same fields), so assertions are looked
+        // through as well.
         if (expr.type.kind === "record" && expected.kind === "union") {
             let literal = node;
-            while (ts.isParenthesizedExpression(literal) || ts.isSatisfiesExpression(literal))
+            while (ts.isParenthesizedExpression(literal) ||
+                ts.isSatisfiesExpression(literal) ||
+                ts.isAsExpression(literal) ||
+                ts.isTypeAssertion(literal))
                 literal = literal.expression;
             const def = this.unions.get(expected.unionId);
             if (def?.discriminant && ts.isObjectLiteralExpression(literal)) {
@@ -7327,7 +8503,7 @@ export class Lowerer {
                     : [];
             const errorOptions = parts.some((part) => {
                 const sym = part.getAliasSymbol() ?? part.getSymbol();
-                return sym?.name === "ErrorOptions" && this.isStdlibSymbol(sym);
+                return (sym !== undefined && ts.symbolName(sym) === "ErrorOptions" && this.isStdlibSymbol(sym));
             });
             if (errorOptions) {
                 const actual = this.typeOf(node);
@@ -7357,7 +8533,7 @@ export class Lowerer {
         let literal = node;
         while (ts.isParenthesizedExpression(literal))
             literal = literal.expression;
-        if (isJsSourceFile(node.getSourceFile()) &&
+        if (isJsSourceFile(ts.getSourceFileOfNode(node)) &&
             !ts.isArrayLiteralExpression(literal) &&
             e.kind === "dynFrom" &&
             e.value.type.kind === "array") {
@@ -7376,7 +8552,8 @@ export class Lowerer {
         // node's CHECKER type proves those arms away, they trap instead — the
         // sub-union narrowing bridge (narrowedRetagHelper).
         if (e.type.kind === "union" && expected.kind === "union" && !typeEquals(e.type, expected)) {
-            const helper = this.narrowedRetagHelper(node, e.type.unionId, expected.unionId, e.loc);
+            const helper = this.narrowedRetagHelper(node, e.type.unionId, expected.unionId, e.loc) ??
+                uninhabitedArmRetagHelper(this, node, e.type.unionId, expected.unionId, e.loc);
             if (helper) {
                 e = { kind: "call", callee: helper, args: [e], type: expected, loc: e.loc };
             }
@@ -7386,7 +8563,7 @@ export class Lowerer {
             // never reinterpret an object payload as a scalar union arm.
             if (e.type.kind === "union" &&
                 !typeEquals(e.type, expected) &&
-                isJsSourceFile(node.getSourceFile()) &&
+                isJsSourceFile(ts.getSourceFileOfNode(node)) &&
                 this.dynConvertible(e.type)) {
                 const sourceArms = this.unions.get(e.type.unionId)?.arms ?? [];
                 const targetArms = this.unions.get(expected.unionId)?.arms ?? [];
@@ -7423,7 +8600,7 @@ export class Lowerer {
         const sym = this.resolveValueSymbol(n);
         if (!sym)
             return null;
-        const decls = this.checker.declarationsOf(sym);
+        const decls = sym.declarations;
         if (decls.length === 0)
             return null;
         const units = new Set();
@@ -7434,7 +8611,7 @@ export class Lowerer {
                 !ts.isIdentifier(d.name) ||
                 !ts.isVariableDeclarationList(d.parent) ||
                 !ts.isVariableStatement(d.parent.parent) ||
-                d.getSourceFile().isDeclarationFile ||
+                ts.getSourceFileOfNode(d).isDeclarationFile ||
                 (ts.getCombinedModifierFlags(d) & ts.ModifierFlags.Ambient) !== 0) {
                 return null;
             }
@@ -7551,6 +8728,9 @@ export class Lowerer {
         if (expected) {
             if (ts.isConditionalExpression(node))
                 return lowerTernary(this, node, expected);
+            const escaped = this.neverAssertionInto(node, expected);
+            if (escaped)
+                return escaped;
             const fresh = this.emptyCollectionFor(node, expected);
             if (fresh)
                 return this.coerceInto(node, fresh, expected);
@@ -7600,10 +8780,10 @@ export class Lowerer {
             // Construct its actual storage here so identity and WeakMap lifetime
             // belong to the array the program keeps, rather than a typed snapshot.
             if (ts.isArrayLiteralExpression(x) &&
-                x.elements.every((element) => !ts.isSpreadElement(element) && !ts.isOmittedExpression(element))) {
+                x.elements.nodes.every((element) => !ts.isSpreadElement(element) && !ts.isOmittedExpression(element))) {
                 return {
                     kind: "dynArrLit",
-                    elems: x.elements.map((element) => this.lowerExprExpecting(element, DYN)),
+                    elems: x.elements.nodes.map((element) => this.lowerExprExpecting(element, DYN)),
                     type: DYN,
                     loc: locOf(x),
                 };
@@ -7617,16 +8797,17 @@ export class Lowerer {
                     : [];
             const builtinOption = (name) => parts.some((part) => {
                 const sym = part.getAliasSymbol() ?? part.getSymbol();
-                return sym?.name === name && this.isStdlibSymbol(sym);
+                return ts.symbolNameOf(sym) === name && this.isStdlibSymbol(sym);
             });
             if (ts.isObjectLiteralExpression(x)) {
-                if (isJsSourceFile(x.getSourceFile()) ||
+                if (isJsSourceFile(ts.getSourceFileOfNode(x)) ||
                     builtinOption("RequestInit") ||
                     builtinOption("ErrorOptions") ||
                     builtinOption("SpawnOptions") ||
                     builtinOption("UrlObject") ||
                     builtinOption("URLFormatOptions") ||
-                    !this.mapTypeOf(this.typeOf(x))) {
+                    !this.mapTypeOf(this.typeOf(x)) ||
+                    this.excessJsContextualProperty(x, parts)) {
                     return lowerDynObjectLiteral(this, x);
                 }
             }
@@ -7647,24 +8828,24 @@ export class Lowerer {
                 // a unit-only-element array — a checker type that degraded to one
                 // (`[]`-flavored inference over a populated literal) carries no
                 // element information.
-                const nonUnitElems = x.elements.some((el) => !ts.isOmittedExpression(el) &&
+                const nonUnitElems = x.elements.nodes.some((el) => !ts.isOmittedExpression(el) &&
                     el.kind !== ts.SyntaxKind.NullKeyword &&
                     !(ts.isIdentifier(el) && el.text === "undefined"));
                 const def = this.unions.get(expected.unionId);
                 const arms = (def?.arms ?? []).filter((a) => (a.kind === "array" && !(nonUnitElems && this.unitOnlyElem(a.elem))) ||
                     (a.kind === "record" &&
                         !!this.shapes.get(a.shapeId)?.tuple &&
-                        this.shapes.get(a.shapeId).fields.length === x.elements.length &&
-                        !x.elements.some(ts.isSpreadElement)));
+                        this.shapes.get(a.shapeId).fields.length === x.elements.nodes.length &&
+                        !x.elements.nodes.some(ts.isSpreadElement)));
                 let arm = arms.length === 1 ? arms[0] : undefined;
                 if (!arm &&
                     arms.length > 1 &&
-                    x.elements.length > 0 &&
-                    x.elements.every((el) => !ts.isSpreadElement(el) && !ts.isOmittedExpression(el))) {
+                    x.elements.nodes.length > 0 &&
+                    x.elements.nodes.every((el) => !ts.isSpreadElement(el) && !ts.isOmittedExpression(el))) {
                     const ownType = this.mapTypeOf(this.typeOf(x));
                     arm = arms.find((candidate) => ownType !== null && typeEquals(candidate, ownType));
                     if (!arm) {
-                        const elements = x.elements.map((el) => tryLowerExpression(this, el));
+                        const elements = x.elements.nodes.map((el) => tryLowerExpression(this, el));
                         arm = arms.find((candidate) => candidate.kind === "array" &&
                             elements.every((element) => element !== null && this.widthLiftPlan(element.type, candidate.elem) !== null));
                     }
@@ -7675,14 +8856,20 @@ export class Lowerer {
                 }
             }
         }
-        let e = this.lowerExpr(node);
-        if ((expected?.kind === "union" && this.armTag(expected.unionId, UNDEFINED_T) >= 0) ||
-            (expected?.kind === "dyn" && isJsSourceFile(node.getSourceFile()))) {
+        const e = this.lowerExpr(node);
+        return expected ? this.coerceExistingInto(node, e, expected) : e;
+    }
+    /** 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, e, expected) {
+        if ((expected.kind === "union" && this.armTag(expected.unionId, UNDEFINED_T) >= 0) ||
+            (expected.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(node)))) {
             // A destination that accepts undefined must retain an unchecked
             // read's storage value even when the checker still calls it present.
             e = this.runtimeOptionalSourceValue(node, e) ?? e;
         }
-        return expected ? this.coerceInto(node, e, expected) : e;
+        return this.coerceInto(node, e, expected);
     }
     /** An unannotated empty collection has no existing elements or aliases
      * that constrain its layout. An explicit type argument still wins. */
@@ -7692,13 +8879,13 @@ export class Lowerer {
             value = value.expression;
         if (!ts.isNewExpression(value) ||
             !ts.isIdentifier(value.expression) ||
-            (value.arguments?.length ?? 0) !== 0 ||
-            (value.typeArguments?.length ?? 0) !== 0)
+            (value.arguments?.nodes.length ?? 0) !== 0 ||
+            (value.typeArguments?.nodes.length ?? 0) !== 0)
             return null;
         const symbol = this.resolveValueSymbol(value.expression);
         if (!symbol || !this.isStdlibSymbol(symbol))
             return null;
-        const kind = symbol.name === "Map" ? "map" : symbol.name === "Set" ? "set" : null;
+        const kind = ts.symbolName(symbol) === "Map" ? "map" : ts.symbolName(symbol) === "Set" ? "set" : null;
         if (!kind)
             return null;
         const arms = expected.kind === "union" ? (this.unions.get(expected.unionId)?.arms ?? []) : [expected];
@@ -7752,6 +8939,17 @@ export class Lowerer {
         this.addedUndefinedArms.set(t.unionId, { type, unions: this.unions.revision });
         return type;
     }
+    /** 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, to) {
+        if (typeEquals(from, to))
+            return true;
+        if (to.inner.kind === "void")
+            return from.inner.kind !== "void";
+        return (this.dynConvertible(from) &&
+            canDynCheckTo(to, (id) => this.shapes.get(id), (id) => this.unions.get(id)));
+    }
     /** 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),
@@ -7786,15 +8984,24 @@ export class Lowerer {
         // storage directly, just like arguments and variable initializers.
         // Contextual types (such as Proxy descriptors' symbol-valued fields)
         // must not force an intermediate record with incompatible field slots.
+        if (this.returnsLiteralIntoDyn(node, expected))
+            return this.lowerExprExpecting(node, expected);
+        return this.asyncReturnValueOf(node, this.lowerExpr(node), expected);
+    }
+    /** A fresh JS object literal returned into a checked-native (dyn) result,
+     * which lowers straight into that storage. */
+    returnsLiteralIntoDyn(node, expected) {
         let literal = node;
         while (ts.isParenthesizedExpression(literal))
             literal = literal.expression;
-        if (expected.kind === "dyn" &&
-            isJsSourceFile(node.getSourceFile()) &&
-            ts.isObjectLiteralExpression(literal)) {
-            return this.lowerExprExpecting(node, expected);
-        }
-        const e = this.lowerExpr(node);
+        return (expected.kind === "dyn" &&
+            isJsSourceFile(ts.getSourceFileOfNode(node)) &&
+            ts.isObjectLiteralExpression(literal));
+    }
+    /** 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. */
+    asyncReturnValueOf(node, e, expected) {
         if (expected.kind === "void" && e.kind === "unitLit")
             return null;
         if (this.ctx.isAsync && e.type.kind === "promise" && expected.kind !== "promise") {
@@ -7858,10 +9065,28 @@ export class Lowerer {
         }
         return s;
     }
+    /** `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, e, expected) {
+        if (!this.adoptsReturnedPromise())
+            return null;
+        const mp = promiseArmedUnionOf(this, e.type);
+        if (!mp || promiseArmedUnionOf(this, expected))
+            return null;
+        const stmt = maybePromiseReturnStmt(this, e, mp, expected, (x) => this.coerceInto(node, x, expected));
+        if (stmt === null) {
+            this.unsupported("SC1090", node, `returning '${this.fmt(e.type)}' from an async function whose result is '${this.fmt(expected)}' (an arm does not convert to the result)`);
+        }
+        return stmt;
+    }
     lowerReturnOf(node, loc) {
         const expected = this.ctx.returnType;
         if (expected.kind === "void") {
             let e = this.lowerExpr(node);
+            const flattened = this.maybePromiseReturn(node, e, expected);
+            if (flattened)
+                return flattened;
             if (this.ctx.isAsync && e.type.kind === "promise") {
                 if (this.adoptsReturnedPromise())
                     return this.adoptingReturn(e, VOID, (x) => x);
@@ -7869,6 +9094,14 @@ export class Lowerer {
             }
             if (e.kind === "unitLit")
                 return { kind: "return", value: null, loc };
+            // `return c ? f() : g()` over void calls: a void conditional has no
+            // value representation, so its branch selection becomes control flow.
+            if (e.kind === "ternary" && e.type.kind === "void") {
+                const branch = (x) => x.kind === "ternary" && x.type.kind === "void"
+                    ? { kind: "if", cond: x.cond, then: [branch(x.then)], else_: [branch(x.else_)], loc }
+                    : { kind: "exprStmt", expr: x, loc };
+                return { kind: "block", body: [branch(e), { kind: "return", value: null, loc }], loc };
+            }
             if (e.type.kind === "void")
                 return { kind: "return", value: e, loc };
             return {
@@ -7880,6 +9113,16 @@ export class Lowerer {
                 loc,
             };
         }
+        if (this.adoptsReturnedPromise() && !this.returnsLiteralIntoDyn(node, expected)) {
+            // The async return lowers its operand untyped first (a promise
+            // adopts before its payload converts); a maybe-promise union needs
+            // the statement form, which branches between adoption and fulfillment.
+            const e = this.lowerExpr(node);
+            const flattened = this.maybePromiseReturn(node, e, expected);
+            if (flattened)
+                return flattened;
+            return { kind: "return", value: this.asyncReturnValueOf(node, e, expected), loc };
+        }
         return { kind: "return", value: this.lowerReturnValue(node), loc };
     }
     maybeNarrow(expr, node) {
@@ -8036,7 +9279,7 @@ export class Lowerer {
             // declaration poisons under a source-anchored diagnostic, deferred
             // like any collection fence — never a crashed CLI.
             if (isCheckerPanic(e)) {
-                const decl = symbol ? this.checker.declarationsOf(symbol)[0] : undefined;
+                const decl = symbol ? symbol.declarations[0] : undefined;
                 sink.push(checkerPanicDiag(e.message.split("\n", 1)[0], decl ? locOf(decl) : { file: this.entry.fileName, start: 0, end: 0 }));
             }
             else if (!(e instanceof PoisonError)) {
@@ -8147,27 +9390,27 @@ export class Lowerer {
         const typeNodes = [];
         const symbolRoots = [];
         for (const decl of decls) {
-            for (const member of decl.members) {
+            for (const member of decl.members.nodes) {
                 if ((ts.isConstructorDeclaration(member) ||
                     ts.isMethodDeclaration(member) ||
                     ts.isGetAccessor(member) ||
                     ts.isSetAccessor(member)) &&
                     (!ts.isMethodDeclaration(member) || member.typeParameters === undefined)) {
-                    for (const param of member.parameters) {
+                    for (const param of member.parameters.nodes) {
                         if (param.initializer)
                             defaultTypeNodes.push(param.initializer);
                     }
                 }
             }
-            if (!isJsSourceFile(decl.getSourceFile()))
+            if (!isJsSourceFile(ts.getSourceFileOfNode(decl)))
                 continue;
-            for (const member of decl.members) {
+            for (const member of decl.members.nodes) {
                 if (ts.isConstructorDeclaration(member)) {
-                    for (const param of member.parameters) {
+                    for (const param of member.parameters.nodes) {
                         if (param.initializer)
                             typeNodes.push(param.initializer);
                     }
-                    for (const stmt of member.body?.statements ?? []) {
+                    for (const stmt of member.body?.statements?.nodes ?? []) {
                         if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression))
                             continue;
                         if (stmt.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
@@ -8186,13 +9429,13 @@ export class Lowerer {
                 if (ts.isMethodDeclaration(member) ||
                     ts.isGetAccessor(member) ||
                     ts.isSetAccessor(member)) {
-                    for (const param of member.parameters) {
+                    for (const param of member.parameters.nodes) {
                         if (param.initializer)
                             typeNodes.push(param.initializer);
                     }
                     // npm-static implicit-any classification resolves body parameter
                     // references while collecting the method's shape.
-                    if (implicitMonoFile(decl.getSourceFile()) && member.body) {
+                    if (implicitMonoFile(ts.getSourceFileOfNode(decl)) && member.body) {
                         symbolRoots.push(member.body);
                     }
                 }
@@ -8219,6 +9462,43 @@ export class Lowerer {
     lowerClassExpressionInfo(expr) {
         return lowerClassExpressionInfo(this, expr);
     }
+    /** Depth of the whole-program analyses that query types across every
+     * file before reachability is known (speculativeTypeQueries). */
+    speculativeTypeQueryDepth = 0;
+    /** 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) {
+        this.speculativeTypeQueryDepth++;
+        try {
+            analysis();
+        }
+        finally {
+            this.speculativeTypeQueryDepth--;
+        }
+    }
+    /** 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) {
+        if (this.speculativeTypeQueryDepth === 0 || this.fnStack.length > 0) {
+            this.lowerClassExpressionInfo(decl);
+            return true;
+        }
+        try {
+            this.lowerClassExpressionInfo(decl);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof PoisonError)
+                return false;
+            throw e;
+        }
+    }
     lowerClassExpression(expr) {
         return lowerClassExpression(this, expr);
     }
@@ -8226,6 +9506,14 @@ export class Lowerer {
     findMethodOn(info, name) {
         return findMethodOn(this, info, name);
     }
+    /** A class whose root is the runtime's %Error (builtin errors and their
+     * program subclasses). */
+    isErrorRootedClass(className) {
+        let info = this.classes.get(className) ?? null;
+        while (info && info.base)
+            info = info.base;
+        return info?.def.name === "%Error";
+    }
     isSubclassOf(sub, sup) {
         return isSubclassOf(this, sub, sup);
     }
@@ -8342,7 +9630,7 @@ export class Lowerer {
     *classMethodMembers(info, includeAbstract = false) {
         if (!info.decl)
             return; // builtin error classes: runtime-provided bodies
-        for (const member of info.decl.members) {
+        for (const member of info.decl.members.nodes) {
             const fnLike = ts.isMethodDeclaration(member) || ts.isGetAccessor(member) || ts.isSetAccessor(member)
                 ? member
                 : null;
@@ -8406,6 +9694,9 @@ export class Lowerer {
     lowerDefaultExport(stmt) {
         return lowerDefaultExport(this, stmt);
     }
+    /** Statements %main runs before any module initializer: runtime
+     * registrations the lowering passes add. */
+    mainPrelude = [];
     buildMain() {
         return buildMain(this);
     }
@@ -8461,6 +9752,92 @@ export class Lowerer {
     declareHiddenLocal(name, type) {
         return declareContextLocal(this.ctx, name, type, false, undefined, undefined);
     }
+    /** 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, nameNode, elemShapes, params, prologue) {
+        const loc = locOf(decl);
+        const name = nameNode.text;
+        const fn = decl.parent;
+        const symbol = this.checker.getSymbolAtLocation(nameNode);
+        const isRead = (id) => id !== nameNode && this.checker.getSymbolAtLocation(id) === symbol;
+        const pure = fn !== undefined && symbol !== undefined && onlyForwarded(this, fn, isRead);
+        // A forwarded-only tuple is never built: a tuple with optional
+        // positions (`Parameters<(n?: T) => R>`, whose length varies per call)
+        // forwards its slots, an omitted position as undefined — which a
+        // callee's default treats exactly as an omitted argument. Its length
+        // is the one read that would observe the difference.
+        const tupleType = pure &&
+            elemShapes.length > 0 &&
+            this.mapTypeOf(this.typeOf(nameNode)) === null &&
+            !readsLength(fn, isRead)
+            ? this.forwardedSlotsTuple(elemShapes)
+            : this.irTypeOf(nameNode);
+        const slots = elemShapes.map((shape, i) => {
+            const slot = this.declareHiddenLocal(`%${name}.${i}`, shape.type);
+            params.push({ localId: slot.id, name: `%${name}.${i}`, type: shape.type });
+            return slot;
+        });
+        const body = this.declareLocal(nameNode, name, tupleType, true);
+        if (pure) {
+            this.ctx.pureTuples.set(body.id, slots);
+            return;
+        }
+        const init = this.tupleOfSlots(slots, tupleType, nameNode, loc);
+        prologue.push({ kind: "varDecl", localId: body.id, init, loc });
+    }
+    /** `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. */
+    neverAssertionInto(node, expected) {
+        if (!(ts.isAsExpression(node) || ts.isTypeAssertion(node)))
+            return null;
+        if (expected.kind === "f64" || expected.kind === "dyn" || expected.kind === "union")
+            return null;
+        if (!(this.checker.getTypeFromTypeNode(node.type).flags & ts.TypeFlags.Never))
+            return null;
+        const innerTs = this.typeOf(node.expression);
+        if (!(innerTs.flags & ts.TypeFlags.Any) && this.mapTypeOf(innerTs)?.kind !== "dyn")
+            return null;
+        if (!canDynCheckTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id)))
+            return null;
+        const inner = this.lowerExpr(node.expression);
+        if (inner.type.kind !== "dyn")
+            return null;
+        return { kind: "dynCheck", value: inner, type: expected, loc: locOf(node) };
+    }
+    /** The tuple record of a forwarded-only rest tuple's native slots. */
+    forwardedSlotsTuple(elemShapes) {
+        const fields = elemShapes.map((shape, i) => ({ name: String(i), type: shape.type }));
+        fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        return { kind: "record", shapeId: this.shapes.intern(fields, true) };
+    }
+    /** A fresh tuple holding the given positional slots, typed `tupleType`
+     * (a tuple record, or the empty-array form of `[]`). */
+    tupleOfSlots(slots, tupleType, blame, loc) {
+        if (slots.length === 0) {
+            if (tupleType.kind !== "array")
+                this.badType(blame, this.typeOf(blame));
+            return { kind: "arrayLit", elems: [], type: tupleType, loc };
+        }
+        const shape = tupleType.kind === "record" ? this.shapes.get(tupleType.shapeId) : undefined;
+        if (!shape?.tuple || shape.fields.length !== slots.length)
+            this.badType(blame, this.typeOf(blame));
+        return {
+            kind: "recordLit",
+            fields: slots.map((slot, i) => {
+                const field = shape.fields.find((f) => f.name === String(i));
+                return {
+                    name: field.name,
+                    value: this.coerceToExpected({ kind: "varRef", localId: slot.id, type: slot.type, loc }, field.type),
+                };
+            }),
+            type: tupleType,
+            loc,
+        };
+    }
     /** 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`
@@ -8495,6 +9872,15 @@ export class Lowerer {
             return defaultAfterUndefined(undefinedValue, this.coerceInto(node, absent, expected));
         };
         decls.forEach((decl, i) => {
+            // A fixed-tuple rest parameter owns every remaining (flattened)
+            // shape, possibly none for `[]` (restTupleShapes).
+            if (decl.dotDotDotToken !== undefined &&
+                ts.isIdentifier(decl.name) &&
+                i === decls.length - 1 &&
+                (shapes[i] === undefined ? shapes.length === i : shapes[i].restTuple === true)) {
+                this.declareRestTupleParam(decl, decl.name, shapes.slice(i), params, prologue);
+                return;
+            }
             const shape = shapes[i];
             if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
                 // Pattern parameter: one hidden ABI slot carries the source value;
@@ -8541,7 +9927,7 @@ export class Lowerer {
                         // RequireObjectCoercible; use V8's default-expression spelling.
                         if (abi.kind === "dyn" &&
                             ts.isObjectBindingPattern(decl.name) &&
-                            decl.name.elements.length === 0) {
+                            decl.name.elements.nodes.length === 0) {
                             prologue.push({
                                 kind: "exprStmt",
                                 expr: {
@@ -8620,10 +10006,32 @@ export class Lowerer {
                     srcType = pickedT;
                     srcRef = () => ({ kind: "varRef", localId: src.id, type: pickedT, loc });
                 }
+                else {
+                    // `({ groups }) => ...` over matchAll rows.
+                    const groupsSource = matchGroupsPatternSource(this, decl.name, srcRef(), () => matchCallbackParamGroupsOf(this, decl), loc);
+                    if (groupsSource !== null) {
+                        const src = this.declareHiddenLocal("%psrc", groupsSource.type);
+                        prologue.push({ kind: "varDecl", localId: src.id, init: groupsSource, loc });
+                        const groupsT = groupsSource.type;
+                        srcType = groupsT;
+                        srcRef = () => ({ kind: "varRef", localId: src.id, type: groupsT, loc });
+                    }
+                }
                 this.lowerBindingPattern(decl.name, srcRef, srcType, true, prologue);
                 return;
             }
             const name = decl.name.text;
+            if (shape.entryNarrow) {
+                // A typed override parameter over an inherited checked-value slot:
+                // the body local narrows from the dyn argument at entry.
+                const loc = locOf(decl);
+                const slot = this.declareHiddenLocal(name, shape.type);
+                params.push({ localId: slot.id, name, type: shape.type });
+                const narrowed = this.coerceInto(decl.name, { kind: "varRef", localId: slot.id, type: shape.type, loc }, shape.entryNarrow);
+                const body = this.declareLocal(decl.name, name, shape.entryNarrow, true);
+                prologue.push({ kind: "varDecl", localId: body.id, init: narrowed, loc });
+                return;
+            }
             if (shape.mode === "omittable" && shape.bodyType && decl.initializer) {
                 const abi = shape.type;
                 if (abi.kind === "dyn") {
@@ -8794,6 +10202,11 @@ export class Lowerer {
         if (!symbol)
             return null;
         const direct = this.resolveKey(symbol, ident);
+        if (direct && this.ctx.pureTuples.has(direct.id)) {
+            // onlyForwarded proved every read forwards; a plain read here means
+            // the analysis and the lowering disagree.
+            throw new InternalCompilerError(`lowerer bug: forwarded-only tuple '${ident.text}' read as a value`);
+        }
         if (direct)
             return direct;
         // A PARAMETER PROPERTY declares two symbols: references resolve to the
@@ -8801,11 +10214,11 @@ export class Lowerer {
         // symbol — which is what declareParams registered the local under.
         // On a miss, normalize to the declaration's key and retry (ordinary
         // bindings never reach this — their two sides intern to one symbol).
-        const vd = this.checker.valueDeclarationOf(symbol);
+        const vd = symbol.valueDeclaration;
         if (vd &&
             ts.isParameter(vd) &&
             ts.isIdentifier(vd.name) &&
-            vd.modifiers?.some((m) => m.kind === ts.SyntaxKind.PublicKeyword ||
+            vd.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.PublicKeyword ||
                 m.kind === ts.SyntaxKind.PrivateKeyword ||
                 m.kind === ts.SyntaxKind.ProtectedKeyword ||
                 m.kind === ts.SyntaxKind.ReadonlyKeyword ||
@@ -8819,8 +10232,8 @@ export 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() {
-        return this.resolveKey(undefined);
+    resolveThis(blame) {
+        return this.resolveKey(undefined, blame);
     }
     peekLocal(ident) {
         let symbol = this.checker.getSymbolAtLocation(ident);
@@ -8845,9 +10258,7 @@ export class Lowerer {
                 this.runtimeOptionalRoots.set(entry, root);
         });
         if (resolved.error !== null) {
-            const location = blame ??
-                (symbol === undefined ? undefined : this.checker.declarationsOf(symbol)[0]) ??
-                this.entry;
+            const location = blame ?? (symbol === undefined ? undefined : symbol.declarations[0]) ?? this.entry;
             const message = `the binding '${resolved.origin.name}' captured through a plain nested function (the declaration has no static storage a capture can thread — bind the value through a typed const, or read it in the declaring scope)`;
             this.unsupported("SC1090", location, message);
         }
@@ -8888,6 +10299,10 @@ export class Lowerer {
         const ctx = this.ctx;
         if (!ctx.selfSymbol)
             return false;
+        // A reassigned JavaScript declaration names its module global, which
+        // may hold another function by the time the body runs.
+        if (isRebindableFunctionSymbol(this, ctx.selfSymbol))
+            return false;
         // The self binding can be shadowed by a scoped local of the same symbol?
         // No — a shadow is a different symbol; symbol identity is exact.
         return this.checker.getSymbolAtLocation(ident) === ctx.selfSymbol;
@@ -8920,7 +10335,7 @@ export class Lowerer {
         // concrete signature — name the shape instead of the generic
         // binding-form text.
         if (symbol) {
-            const d = this.checker.valueDeclarationOf(symbol);
+            const d = symbol.valueDeclaration;
             if (d && ts.isVariableDeclaration(d) && d.initializer === undefined) {
                 const t = this.checker.getTypeOfSymbol(symbol);
                 const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
@@ -8934,7 +10349,7 @@ export class Lowerer {
         // assignment are `undefined`, and this binding's type has no slot for
         // that value — name the shape instead of the generic no-lowering text.
         if (symbol) {
-            const d = this.checker.valueDeclarationOf(symbol);
+            const d = symbol.valueDeclaration;
             if (d &&
                 ts.isVariableDeclaration(d) &&
                 (ts.getCombinedNodeFlags(d) & ts.NodeFlags.BlockScoped) === 0) {
@@ -9067,7 +10482,9 @@ export class Lowerer {
     }
     isNpmFile = (sf) => sf.isDeclarationFile &&
         (sf.fileName.includes("/node_modules/") || workspacePackageOfPath(sf.fileName) !== null) &&
-        !this.isStdlibFile(sf);
+        !this.isStdlibFile(sf) &&
+        // A bundled copy's forwarder to a package shim types compiled code.
+        !isBundledShimForwarder(sf.fileName);
     npmPackageOf(type) {
         return npmPackageOf(this, type);
     }
@@ -9315,8 +10732,13 @@ export class Lowerer {
         // dispatch. The general identifier-call paths have no lowering for a
         // promise-returning ambient global, and `import` is a keyword callee no
         // identifier path matches.
+        const webAssembly = lowerWebAssemblyCall(this, expr);
+        if (webAssembly !== null)
+            return webAssembly;
+        refuseWebAssemblyUse(this, expr.expression);
         return (lowerLifetimeRegionCall(this, expr) ??
             lowerInternTableCall(this, expr) ??
+            lowerThreadSlotsCall(this, expr) ??
             lowerFfiCall(this, expr) ??
             lowerFetchCall(this, expr) ??
             lowerStaticFetchCompanionCall(this, expr) ??
@@ -9327,7 +10749,10 @@ export class Lowerer {
             lowerStaticReadableStreamReaderCall(this, expr) ??
             lowerStaticResponseCall(this, expr) ??
             lowerStaticBlobCall(this, expr) ??
+            lowerWebCryptoCall(this, expr) ??
             lowerKeyObjectCall(this, expr) ??
+            lowerEcdhCall(this, expr) ??
+            lowerNetAddressCall(this, expr) ??
             lowerFetchElementMethodCall(this, expr) ??
             lowerDynamicImportCall(this, expr) ??
             lowerCall(this, expr));
@@ -9454,13 +10879,20 @@ export class Lowerer {
         return inheritsBuiltinEmitterCtor(this, info);
     }
     lowerNew(expr) {
+        const webAssembly = lowerWebAssemblyNew(this, expr);
+        if (webAssembly !== null)
+            return webAssembly;
+        refuseWebAssemblyUse(this, expr.expression, "new ");
         const builtin = lowerLifetimeRegionNew(this, expr) ??
             lowerInternTableNew(this, expr) ??
+            lowerThreadSlotsNew(this, expr) ??
             lowerAbortControllerNew(this, expr) ??
+            lowerDisposableStackNew(this, expr) ??
             lowerEventTargetNew(this, expr) ??
             lowerFetchWebNew(this, expr) ??
             lowerResponseNew(this, expr) ??
             lowerBlobNew(this, expr) ??
+            lowerNetAddressNew(this, expr) ??
             lowerStaticReadableStreamNew(this, expr) ??
             lowerConsoleNew(this, expr);
         return (builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr)));
@@ -9541,9 +10973,21 @@ export class Lowerer {
         if (mapped?.kind === "moduleNs" && mapped.moduleId.startsWith("builtin:")) {
             return mapped.moduleId.slice("builtin:".length);
         }
+        // A nullable namespace binding (`const os: typeof NodeOs | null`, a
+        // probed process.getBuiltinModule result) read where the checker
+        // narrowed it present: its members key the same tables.
+        if (stored?.kind === "union") {
+            const present = this.unions.get(stored.unionId)?.arms.filter((arm) => !isUnitType(arm));
+            const only = present?.length === 1 ? present[0] : undefined;
+            if (only?.kind === "moduleNs" && only.moduleId.startsWith("builtin:")) {
+                const narrowed = this.mapTypeOf(this.typeOf(expr));
+                if (narrowed?.kind === "moduleNs" && narrowed.moduleId === only.moduleId)
+                    return only.moduleId.slice("builtin:".length);
+            }
+        }
         if (ts.isIdentifier(expr)) {
             const symbol = this.checker.getSymbolAtLocation(expr);
-            const decl = symbol ? this.checker.declarationsOf(symbol)[0] : undefined;
+            const decl = symbol ? symbol.declarations[0] : undefined;
             if (!decl)
                 return null;
             // The CommonJS twin: `const fs = require("fs")` binds the same
@@ -9612,7 +11056,7 @@ export class Lowerer {
         }
         if (ts.isIdentifier(expr)) {
             const symbol = this.checker.getSymbolAtLocation(expr);
-            const decl = symbol ? this.checker.declarationsOf(symbol)[0] : undefined;
+            const decl = symbol ? symbol.declarations[0] : undefined;
             if (!decl)
                 return null;
             // The DEFAULT-import twin: Node's default export of a CJS builtin
@@ -9663,9 +11107,47 @@ export class Lowerer {
                 return { module: "fs", member: "realpathSync.native" };
             }
         }
+        // timers/promises scheduler.wait / scheduler.yield: methods of the
+        // module's scheduler object, dispatched as module members.
+        if (access.name.text === "wait" || access.name.text === "yield") {
+            const owner = access.expression;
+            const imported = ts.isIdentifier(owner)
+                ? this.builtinImportOf(owner)
+                : ts.isPropertyAccessExpression(owner)
+                    ? this.builtinMemberOf(owner)
+                    : null;
+            if (imported?.module === "timers/promises" && imported.member === "scheduler") {
+                return { module: "timers/promises", member: `scheduler.${access.name.text}` };
+            }
+        }
+        // punycode.ucs2.decode / encode: methods of the module's ucs2 object,
+        // dispatched as module members.
+        if (access.name.text === "decode" || access.name.text === "encode") {
+            const owner = access.expression;
+            const imported = ts.isIdentifier(owner)
+                ? this.builtinImportOf(owner)
+                : ts.isPropertyAccessExpression(owner)
+                    ? this.builtinMemberOf(owner)
+                    : null;
+            if (imported?.module === "punycode" && imported.member === "ucs2") {
+                return { module: "punycode", member: `ucs2.${access.name.text}` };
+            }
+        }
         const module = this.builtinNamespaceModuleOf(access.expression);
+        // node:constants is one checked-dynamic object: its members read
+        // through the object itself (builtinConstantsObject), not the tables.
+        if (module === "constants")
+            return null;
         if (module !== null)
             return { module, member: access.name.text };
+        // The events module object IS the EventEmitter class, so the class's
+        // defaultMaxListeners is the module property.
+        if (access.name.text === "defaultMaxListeners" && ts.isIdentifier(access.expression)) {
+            const imported = this.builtinImportOf(access.expression);
+            if (imported?.module === "events" && imported.member === "EventEmitter") {
+                return { module: "events", member: "defaultMaxListeners" };
+            }
+        }
         // The RE-EXPORT FACADE's namespace spelling: `import * as assert from
         // "./facade.js"` over `export { ok } from "node:assert"` (the formatter idiom's
         // universal/assert). The member's symbol is the facade's
@@ -9705,9 +11187,8 @@ export class Lowerer {
                     COPYFILE_FICLONE_FORCE: 4,
                 };
                 const value = own(MODES, expr.name.text);
-                if (value === undefined) {
-                    this.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
-                }
+                if (value === undefined)
+                    return fsConstantMemberRead(expr);
                 return { kind: "numLit", value, type: F64, loc };
             }
         }
@@ -9719,9 +11200,18 @@ export class Lowerer {
             return pathModuleValue(this, `path/${bi.member}`, loc);
         }
         // events.defaultMaxListeners READS the process-wide default (its
-        // write twin routes through emitter.setDefaultMaxChk).
+        // write twin routes through emitter.setDefaultMaxChk). Through an ES
+        // module namespace it reads the namespace's copy instead.
         if (bi.module === "events" && bi.member === "defaultMaxListeners") {
-            return { kind: "libCall", fn: "emitter.getDefaultMax", args: [], type: F64, loc };
+            const esm = ts.isIdentifier(expr.expression) &&
+                esmImportBindingKind(this, expr.expression) === "namespace";
+            return {
+                kind: "libCall",
+                fn: esm ? "emitter.esmDefaultMax" : "emitter.getDefaultMax",
+                args: [],
+                type: F64,
+                loc,
+            };
         }
         if (bi.module === "worker_threads") {
             const value = lowerWorkerMetadata(bi.member, loc);
@@ -9739,6 +11229,15 @@ export class Lowerer {
         if (bi.module === "http" && bi.member === "METHODS") {
             return { kind: "libCall", fn: "http.methods", args: [], type: arrayOf(STRING), loc };
         }
+        if ((bi.module === "http" || bi.module === "https") && bi.member === "globalAgent") {
+            return {
+                kind: "libCall",
+                fn: "http.globalAgent",
+                args: [{ kind: "boolLit", value: bi.module === "https", type: BOOL, loc }],
+                type: DYN,
+                loc,
+            };
+        }
         if (bi.module === "http" && bi.member === "STATUS_CODES") {
             return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
         }
@@ -9760,12 +11259,24 @@ export class Lowerer {
             if (callable)
                 return callable;
         }
-        if (bi.member === "constants" && bi.module === "fs") {
-            // A bare `fs.constants` read (not one of the baked bits above).
-            this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
+        // node:stream/web's exports are the web stream globals themselves: in
+        // JavaScript sources the same identity token as the global spelling
+        // (`require("stream/web").ReadableStream === globalThis.ReadableStream`).
+        if (bi.module === "stream/web" && isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+            return { kind: "strLit", value: `[builtin ${bi.member}]`, type: STRING, loc };
+        }
+        // A bare `fs.constants` read (not one of the baked bits above).
+        if (bi.member === "constants" && bi.module === "fs")
+            return fsConstantsObject(loc);
+        // `stream.Readable` as a JavaScript value: the runtime's untyped
+        // constructor, the base a constructor function inherits.
+        if (isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+            const classKind = builtinMemberClassKind(bi.module, bi.member);
+            if (classKind !== null)
+                return builtinClassValue(classKind, loc);
         }
         if (builtinModuleFnOf(this, bi.module, bi.member)) {
-            this.unsupported("SC1090", expr, `library functions as values (call '${expr.getText()}' directly)`);
+            this.unsupported("SC1090", expr, `library functions as values (call '${ts.getTextOfNode(expr)}' directly)`);
         }
         this.noLowering(`${bi.module}.${bi.member}`, expr, builtinFenceHintOf(bi.module, bi.member), this.checker.getSymbolAtLocation(expr.name));
     }
@@ -9791,6 +11302,8 @@ export class Lowerer {
                 loc,
             };
         }
+        if (bi.module === "fs" && (bi.member === "realpathSync" || bi.member === "realpathSync.native"))
+            return fsRealpathValue(this, bi.member === "realpathSync.native", loc);
         const fn = builtinModuleFnOf(this, bi.module, bi.member);
         return fn ? this.lowerNativeCallableValue(fn, `${bi.module}.${bi.member}`, loc) : null;
     }
@@ -9812,11 +11325,12 @@ export class Lowerer {
         const adapterShape = valueParams
             .map((param) => param.mode === "optional" ? `${param.mode}:${param.defaultValue}` : param.mode)
             .join(",");
-        const key = `${fn.fn}:${typeKey(funcType)}:${adapterShape}`;
+        const key = `${fn.valueFn ?? fn.fn}:${typeKey(funcType)}:${adapterShape}`;
         let fnName = this.builtinCallableValueFns.get(key);
         if (!fnName) {
-            fnName = `%builtin.value.${fn.fn}.${this.builtinCallableValueFns.size}`;
+            fnName = `%builtin.value.${fn.valueFn ?? fn.fn}.${this.builtinCallableValueFns.size}`;
             this.builtinCallableValueFns.set(key, fnName);
+            this.builtinCallableValueNames.set(fnName, display.slice(display.lastIndexOf(".") + 1));
             const params = funcType.params.map((type, index) => ({
                 localId: `arg.${index}`,
                 name: `arg${index}`,
@@ -9874,7 +11388,7 @@ export class Lowerer {
                     loc,
                 };
             });
-            const call = { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
+            const call = { kind: "libCall", fn: fn.valueFn ?? fn.fn, args, type: fn.result, loc };
             const body = fn.result.kind === "void"
                 ? [
                     { kind: "exprStmt", expr: call, loc },
@@ -9919,8 +11433,8 @@ export class Lowerer {
     lowerSpawnCall(expr, loc) {
         return lowerSpawnCall(this, expr, loc);
     }
-    lowerExecFileCall(expr, loc) {
-        return lowerExecFileCall(this, expr, loc);
+    lowerExecFileCall(expr, loc, shell = false) {
+        return lowerExecFileCall(this, expr, loc, shell);
     }
     lowerExecSyncCall(expr, shell, loc) {
         return lowerExecSyncCall(this, expr, shell, loc);
@@ -10118,4 +11632,242 @@ export class Lowerer {
         return lowerStdlibMethodCall(this, call, access);
     }
 }
+/** Whether some read of a binding (identified by `isRead`) in `fn` takes
+ * its `.length`. */
+function readsLength(fn, isRead) {
+    let found = false;
+    ts.walkPreorder(fn, (n) => {
+        if (found)
+            return "stop";
+        if (!ts.isIdentifier(n) || !isRead(n))
+            return undefined;
+        let top = n;
+        while (top.parent &&
+            (ts.isParenthesizedExpression(top.parent) ||
+                ts.isAsExpression(top.parent) ||
+                ts.isTypeAssertion(top.parent) ||
+                ts.isSatisfiesExpression(top.parent) ||
+                ts.isNonNullExpression(top.parent)))
+            top = top.parent;
+        const p = top.parent;
+        if (p && ts.isPropertyAccessExpression(p) && p.expression === top && p.name.text === "length")
+            found = true;
+        return undefined;
+    });
+    return found;
+}
+/** A union of record layouts flowing into one record slot: a function
+ * returning differently-shaped object literals (`{ ok: false }` and
+ * `{ ok: true, size }`, whose union the checker normalizes to arms with
+ * `size?: undefined`) into its declared result type. Each record arm
+ * width-lifts into the slot on its own tag; unit arms take the stranded
+ * TypeError (the checker excluded them). Null when some record arm does
+ * not lift, or when there is a non-record, non-unit arm. */
+function unionArmsWidthLift(lowerer, expr, expected) {
+    if (expr.type.kind !== "union")
+        return null;
+    const unionId = expr.type.unionId;
+    const arms = lowerer.unions.get(unionId)?.arms ?? [];
+    const lifts = [];
+    let records = 0;
+    for (const arm of arms) {
+        if (isUnitType(arm)) {
+            lifts.push(null);
+            continue;
+        }
+        if (arm.kind !== "record")
+            return null;
+        const lift = lowerer.widthLiftPlan(arm, expected);
+        if (!lift)
+            return null;
+        lifts.push(lift);
+        records++;
+    }
+    if (records < 2)
+        return null;
+    const loc = expr.loc;
+    const local = lowerer.declareHiddenLocal("%unionLift", expr.type);
+    const ref = () => ({ kind: "varRef", localId: local.id, type: expr.type, loc });
+    let result = null;
+    for (let tag = arms.length - 1; tag >= 0; tag--) {
+        const lift = lifts[tag];
+        const arm = arms[tag];
+        const branch = lift
+            ? lowerer.applyWidthLift(lift, { kind: "unionNarrow", unionId, tag, value: ref(), type: arm, loc }, expected, loc)
+            : nodeThrowExpr(1, "", `${arm.kind === "nullT" ? "null" : "undefined"} is not representable in a '${lowerer.fmt(expected)}' slot (a value narrowed or asserted past the type still held it)`, expected, loc);
+        result =
+            result === null
+                ? branch
+                : {
+                    kind: "ternary",
+                    cond: {
+                        kind: "unionIsTag",
+                        unionId,
+                        tag,
+                        negated: false,
+                        value: ref(),
+                        type: BOOL,
+                        loc,
+                    },
+                    then: branch,
+                    else_: result,
+                    type: expected,
+                    loc,
+                };
+    }
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "varDecl", localId: local.id, init: expr, loc }],
+        result: result,
+        type: expected,
+        loc,
+    };
+}
+/** A callback passed to a generic call without a return annotation, whose
+ * returns the checker unified into a narrower result type: `trace(name,
+ * async () => (cond ? items : items.map((i) => ({ ...i, sum }))))` infers
+ * `T` from the narrower `Item[]`, though at run time the extended objects
+ * keep `sum`. Converting such a return into the inferred type copies the
+ * records and drops the members the narrower type lacks, which Node keeps
+ * and any later wider view (`Promise<ItemWithSum[]>`) reads back. Refuse
+ * that conversion by name rather than lose the members silently; an
+ * annotation on the callback's return type or on the call's type argument
+ * names a type that keeps them. */
+function refuseInferredCallbackDrops(lowerer, node, actual, expected) {
+    if (typeEquals(actual, expected))
+        return;
+    const structured = (t) => t.kind === "record" || t.kind === "array" || t.kind === "promise";
+    if (!structured(actual) || !structured(expected))
+        return;
+    let site = node;
+    while (yieldsOperand(site))
+        site = site.parent;
+    let fn;
+    if (ts.isReturnStatement(site.parent) && site.parent.expression === site) {
+        fn = site.parent.parent;
+        while (fn && !ts.isFunctionLike(fn))
+            fn = fn.parent;
+    }
+    else if (ts.isArrowFunction(site.parent) && site.parent.body === site) {
+        fn = site.parent;
+    }
+    if (!fn || !(ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) || fn.type)
+        return;
+    let arg = fn;
+    while (ts.isParenthesizedExpression(arg.parent))
+        arg = arg.parent;
+    const call = arg.parent;
+    if (!(ts.isCallExpression(call) || ts.isNewExpression(call)))
+        return;
+    if (!call.arguments?.nodes.includes(arg))
+        return;
+    const dropped = droppedMembers(lowerer, actual, expected, new Set());
+    if (dropped.length === 0)
+        return;
+    lowerer.unsupported("SC1090", node, `returning '${lowerer.fmt(actual)}' from a callback whose result the checker infers as the narrower '${lowerer.fmt(expected)}' (the conversion would drop ${dropped.map((d) => `'${d}'`).join(", ")}, which the object keeps at run time — annotate the callback's return type or the call's type argument with a type that declares them)`);
+}
+/** True when the value of `node`'s parent can be `node`'s own value:
+ * parentheses, `await`, `satisfies`, a non-null assertion, a conditional's
+ * branch, either operand of `??`, `||` and `&&`, and the right operand of a
+ * comma. */
+function yieldsOperand(node) {
+    const p = node.parent;
+    if (p === undefined)
+        return false;
+    if (ts.isParenthesizedExpression(p) ||
+        ts.isAwaitExpression(p) ||
+        ts.isSatisfiesExpression(p) ||
+        ts.isNonNullExpression(p))
+        return true;
+    if (ts.isConditionalExpression(p))
+        return p.whenTrue === node || p.whenFalse === node;
+    if (ts.isBinaryExpression(p)) {
+        const op = p.operatorToken.kind;
+        if (op === ts.SyntaxKind.QuestionQuestionToken ||
+            op === ts.SyntaxKind.BarBarToken ||
+            op === ts.SyntaxKind.AmpersandAmpersandToken)
+            return true;
+        return op === ts.SyntaxKind.CommaToken && p.right === node;
+    }
+    return false;
+}
+/** Member names a structural conversion from `from` into `to` drops:
+ * declared fields of a source record the target record lacks, through
+ * array elements and promise payloads. */
+function droppedMembers(lowerer, from, to, seen) {
+    if (typeEquals(from, to))
+        return [];
+    if (from.kind === "array" && to.kind === "array")
+        return droppedMembers(lowerer, from.elem, to.elem, seen);
+    if (from.kind === "promise" && to.kind === "promise")
+        return droppedMembers(lowerer, from.inner, to.inner, seen);
+    if (from.kind !== "record" || to.kind !== "record")
+        return [];
+    const key = `${from.shapeId}>${to.shapeId}`;
+    if (seen.has(key))
+        return [];
+    seen.add(key);
+    const source = lowerer.shapes.get(from.shapeId);
+    const target = lowerer.shapes.get(to.shapeId);
+    if (!source || !target || source.tuple || target.tuple || target.indexValue)
+        return [];
+    const out = [];
+    for (const f of source.fields) {
+        if (f.name.startsWith("%"))
+            continue;
+        const t = target.fields.find((x) => x.name === f.name);
+        if (!t)
+            out.push(f.name);
+        else
+            out.push(...droppedMembers(lowerer, f.type, t.type, seen).map((n) => `${f.name}.${n}`));
+    }
+    return out;
+}
+/** fs.realpathSync and its .native as function values (fs.realpath stores
+ * `var origRealpathSync = fs.realpathSync`): path and options pass through
+ * unchecked to the runtime, which applies Node's argument handling. */
+function fsRealpathValue(lowerer, native, loc) {
+    const name = native ? "%builtin.fs.realpathSync.native" : "%builtin.fs.realpathSync";
+    if (!lowerer.builtinCallableValueFns.has(name)) {
+        lowerer.builtinCallableValueFns.set(name, name);
+        const params = ["path", "options"].map((id) => ({ localId: id, name: id, type: DYN }));
+        lowerer.liftedFns.push({
+            name,
+            params,
+            returnType: DYN,
+            locals: params.map((p) => ({ id: p.localId, name: p.name, type: DYN, mutable: false })),
+            loc,
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "libCall",
+                        fn: "fs.realpathValue",
+                        args: [
+                            { kind: "varRef", localId: "path", type: DYN, loc },
+                            { kind: "varRef", localId: "options", type: DYN, loc },
+                            { kind: "boolLit", value: native, type: BOOL, loc },
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+        });
+    }
+    return {
+        kind: "dynFrom",
+        value: {
+            kind: "closure",
+            fnName: name,
+            captures: [],
+            type: { kind: "func", params: [DYN, DYN], ret: DYN },
+            loc,
+        },
+        fnName: native ? "native" : "realpathSync",
+        type: DYN,
+        loc,
+    };
+}
 //# sourceMappingURL=lowerer.js.map