@scriptc/compiler 0.4.6 → 0.4.8

package/dist/frontend/lowering/lowerer.js

@@ -1,3 +1,4 @@
+import { programCreatesWrappers, routeWrapperConsumers } from "./primitive-wrappers.js";
 import { markInferredFactChecks, shapeOverlayFileNames } from "../shape-inference/index.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { globalMemberValue } from "./global-values.js";
@@ -5,18 +6,19 @@ import { unionNarrowFailureMessage } from "./union-narrow.js";
 import { arrayClassFieldsFn, arrayClassSpeciesFn, arrayOfClassInstance, arrayRootOf, lowerWithArraySpecies, } from "./builtins/array-classes.js";
 import { canonShadowHook, mapCanonical } from "../canon-map.js";
 import { Normalizer } from "../canon.js";
-import { compactDeclOrigins, inPackageFile, recordOrigin, slotOrigin, } from "./decl-origin.js";
-import { isDeclBoundaryFile } from "../decl-projection.js";
+import { resolveEntryExportSymbol } from "../lib-exports.js";
+import { compactDeclOrigins, recordOrigin, slotOrigin } from "./decl-origin.js";
 import { relieveHeapPressure } from "../../heap-pressure.js";
-import { checkedTable, countTable, fixedScalar, flagScalar, functionTable, irDataTable, journalDump, journalMode, lowerWaveRecorded, mapTable, setTable, waveStats, writeRecords, } from "./unit-journal.js";
+import { checkedTable, countTable, fixedScalar, flagScalar, functionTable, irDataTable, journalDump, journalMode, HeldTables, lowerWaveRecorded, mapTable, setTable, waveStats, writeRecords, } from "./unit-journal.js";
+import { UnitReuse, unitReuseVerify, verifyStoredUnit } from "./unit-reuse.js";
 import { moduleNamespaceDynValue, moduleNamespaceObject, moduleNamespaceValue, } from "./module-namespace-elements.js";
 import { keyedHelperName, moduleTagNumber, portableRelativePath } from "./stable-names.js";
 import { positionTag, StructuralPositions } from "./structural-positions.js";
-import { activeNodeIslands, isForeignType, setActiveNodeIslands, } from "../../node-islands/boundary.js";
+import { activeNodeIslands, setActiveNodeIslands, } from "../../node-islands/boundary.js";
 import { bindingSymbolOfRead, onlyForwarded, stripTypeWrappers } 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 { LoweringFacts } from "./lowering-facts.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";
@@ -30,11 +32,13 @@ 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 { installBuiltinStatics } from "./builtin-statics.js";
+import { functionKeepsRecordSources } from "./record-sources.js";
 import { exprFunctionReference } from "../../ir/function-references.js";
 import { everyStmtList, observeRecordLiteralRebuilds } from "../../ir/traverse.js";
 import { checkedClassAssertion } from "./class-assertions.js";
 import { narrowStoredClassValue, narrowGenericClassValue } from "./class-unions.js";
-import { isOptionalProcessStreamProperty, isOptionalProcessVersionsRead, } from "./builtins/process.js";
+import { isOptionalProcessStreamProperty, isOptionalProcessVersionsRead, programPatchesStdio, } from "./builtins/process.js";
 import { isSettledIteratorValueRead } from "./lower-generators.js";
 import { isRebindableFunctionSymbol } from "./rebindable-functions.js";
 import { concreteCollectionNarrow } from "./collection-narrowing.js";
@@ -63,10 +67,11 @@ import { widthCoerce, applyWidthLift, unionRecordWidthHelper, unionArrayWidthHel
 import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceAdapter, spawnResFnAdapterPlan, spawnResFnAdapter, } from "./coercions/function-adapters.js";
 import { unionRetagMappable, narrowedRetagHelper, uninhabitedArmRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionRouteHelper, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, widthNarrowHelper, } from "./coercions/unions.js";
 import { assertedConversion } from "./coercions/asserted.js";
-import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
+import { boxBuiltinValuesChecked, lowerUtilTypeValue, checkedNativeCallableValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
 import { devirtualizeVirtualCalls } from "./devirtualize.js";
 import { foldRegexSpanReads } from "./regex-span-reads.js";
 import { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js";
+import { runtimeOptionalNarrowings, } from "./runtime-optional-report.js";
 import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js";
 import { NarrowingStability, widenedReceiver } from "./narrowing-stability.js";
 import { ArrayElementStates } from "./runtime-optional-elements.js";
@@ -91,6 +96,7 @@ import { sloppyDynamicWrites } from "./frozen-records.js";
 import { guardFrozenWrites, markSloppyRecordWrites } from "./frozen-records.js";
 import { applyHandleProperties } from "./handle-properties.js";
 import { installBufferValue } from "./containers/bytes.js";
+import { installMutableBuffersArm } from "./buffers.js";
 import { ClassProtocols } from "./class-protocols.js";
 import { earlyReadVarSymbols } from "./var-hoisting.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
@@ -101,7 +107,9 @@ import { returnDispatchReceivers } from "./receiver-returns.js";
 import { analyzeTiers, dynamicStatementCount, } from "../tier-analysis.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import { finalizeClassMethodValues } from "./class-method-values.js";
+import { finalizeRecordLinks } from "./record-links.js";
 import { finalizePrivateBrands } from "./private-brands.js";
+import { finalizeFunctionNames } from "./function-names.js";
 import { INSPECT_CUSTOM_MEMBER, tableKeyFieldType } from "./symbol-fields.js";
 export { newFnCtx } from "./function-context.js";
 /* AST + checker → IR.
@@ -128,11 +136,11 @@ import { literalValues } from "../literal-values.js";
 import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
 import { declarationGroupKey, typeFailureOf } from "./type-failure.js";
 import { dynamicSlotDiag } from "../../diagnostics/dynamic-slots.js";
-import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, stdlibSnapshotValueUseDiag, unsupportedNativeApiDiag, unsupportedPackageValueDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
+import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, hostGlobalDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, stdlibSnapshotValueUseDiag, unsupportedNativeApiDiag, unsupportedPackageValueDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canBoxFuncIntoDyn, 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, cjsExportsAssignedInFunctions, cjsReexportedModules, cjsNamespaceExportNames, isCheckedJsSourceFile, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isFallbackDtsPath, 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 { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportsAssignedInFunctions, cjsReexportedModules, cjsNamespaceExportNames, isCheckedJsSourceFile, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, locOf, orderedImportsOf, npmStaticDepSf7, requireSpecOf, isJsWriteTarget7, isStrictCode, resolveImport, workspacePackageOfPath, } from "../program.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, erasedOverloadMemberType, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isOverloadedCallableMemberType, isUnitOnlyTsType, isWorkerHandleType, isFetchHandleType, jsOpenObjectType, mapType, computeSymbolProvenance, declaresLegacyUrl, declaresWebAssemblyNamespace, ShapeRegistry, noteScopeSensitiveMapping, 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";
@@ -146,7 +154,7 @@ import { mixinCallClassInfoOf, mixinIntersectionInstanceType, } from "./lower-mi
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { funcTypeFromParamShapes, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, requireExactArityValue, collectSignature, collectSignatureInner, lambdaSignature, } from "./call-signatures.js";
 import { dynamicOverloadChoice, guessedOverloadIdentifier } from "./overload-choice.js";
-import { implicitAnyParamSymbolsOf, implicitLocalFnNodeOf, implicitMonoFile, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, genericLocalClassBinding, } from "./generic-functions.js";
+import { implicitAnyParamSymbolsOf, implicitLocalFnNodeOf, implicitMonoFile, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, genericLocalClassBinding, checkGenericIdentityPins, } from "./generic-functions.js";
 import { bindingNeverReassigned } from "./binding-analysis.js";
 import { isMessageListenerCall } from "./expressions/message-listeners.js";
 import { bodyReadsArguments } from "../arguments-usage.js";
@@ -169,7 +177,7 @@ import { lowerTimersPromisesSetInterval, lowerTimeoutMethodCall } from "./builti
 import { lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerStatsMethodCall, } from "./builtins/filesystem.js";
 import { lowerSpawnSyncCall, lowerSpawnCall, lowerExecFileCall } from "./builtins/child-process.js";
 import { lowerExecSyncCall } from "./builtins/child-process-sync.js";
-import { isProcessEnv, envValueType, lowerProcessEnvGet } from "./builtins/environment.js";
+import { isProcessEnv, envValueType, lowerProcessEnvGet, refuseHeldEnvWrite, } from "./builtins/environment.js";
 import { lowerJsonMethodCall, lowerJsonProperty } from "./builtins/json.js";
 import { lowerCryptoComposedCall, lowerCryptoModuleCall } from "./builtins/crypto.js";
 import { lowerUrlMethodCall, lowerSearchParamsMethodCall } from "./builtins/url.js";
@@ -207,12 +215,16 @@ import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShor
 import { lowerRecordFieldCall, lowerObjectMethodCall } from "./lower-calls.js";
 import { fenceCrossBlockNsRef, nsPathPrefix } from "./lower-namespaces.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { partialAssertionFields } from "./partial-assertions.js";
+import { emptyArrayLiteralArm } from "./expressions/array-literals.js";
 import { lowerTernary } from "./lower-exprs.js";
 import { maybePromiseReturnStmt, maybePromiseUnionOf, promiseArmedUnionOf, } from "./maybe-promise.js";
 import { NodeIslandModuleCollector } from "../../node-islands/modules.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
  * function can never collide with it (mangling is injective per prefix). */
 export const ENTRY_NAME = "%main";
+/** Stands for a null binding map in Lowerer.scopedTypeMemos. */
+const NO_BINDINGS = {};
 /** Localized failure: rounds of the declaration flush retry. */
 const MAX_DECLARATION_RETRIES = 16;
 /** The slot kinds the declaration flush retry degrades (stage L2). */
@@ -464,7 +476,16 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
     const externalTypes = options.externalTypes ?? new Map();
     const externalTypeSpecifiersByFile = options.externalTypeSpecifiersByFile ?? directExternalTypeSpecifiersByFile(externalTypes);
     const tierMode = options.tierMode ?? "auto";
+    const runtimeOptionalReport = options.tierReport !== undefined;
+    // One island round lowers the same program through several passes:
+    // validation, reachable emit, the whole-slot comparison, the stream
+    // relowers, historical order and the coverage remainder. They differ only
+    // in their mode flags, so every fact they derive from the program alone is
+    // computed once here and shared (lowering-facts.ts); per-pass state stays
+    // private to the pass.
+    const facts = new LoweringFacts(program, moduleOrder, externalTypeSpecifiersByFile);
     const validation = new Lowerer(program, entry, moduleOrder, {
+        facts,
         frontendServices: options.frontendServices,
         projectCheckJs: options.projectCheckJs ?? false,
         targetPlatform,
@@ -478,6 +499,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         externalTypes,
         externalTypeSpecifiersByFile,
         tierMode,
+        runtimeOptionalReport,
     });
     const ffiValidation = validateFfiImports(validation);
     timing("ffi-validate");
@@ -489,10 +511,12 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
     const reachableEmit = ffiImports.length === 0
         ? validation
         : new Lowerer(program, entry, moduleOrder, {
+            facts,
             frontendServices: options.frontendServices,
             projectCheckJs: options.projectCheckJs ?? false,
             targetPlatform,
             startupCrash,
+            admittedOpinions: options.admittedOpinions,
             inlineRequireCycleCalls,
             dynamicImportRejections: options.dynamicImportRejections,
             ffiImports,
@@ -502,13 +526,14 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ffiBindingSymbols: ffiValidation.symbolsByName,
         });
     for (const d of extraModuleCycleDiags)
         reachableEmit.pushDiag(d);
     for (const d of ffiValidation.diagnostics)
         reachableEmit.pushDiag(d);
-    const emitted = reachableEmit.emitReachable(options.libRoots);
+    const emitted = reachableEmit.emitReachable(options.libRoots, options.unitStore ?? null);
     let { reachable } = emitted;
     let result = emitted.result;
     let resultLowerer = reachableEmit;
@@ -521,10 +546,12 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
     // keep push-down). A program that compiles never takes this path.
     if (result.diagnostics.length > 0 && reachableEmit.hasPartialDegradedTypes()) {
         const whole = new Lowerer(program, entry, moduleOrder, {
+            facts,
             frontendServices: options.frontendServices,
             projectCheckJs: options.projectCheckJs ?? false,
             targetPlatform,
             startupCrash,
+            admittedOpinions: options.admittedOpinions,
             inlineRequireCycleCalls,
             ffiImports,
             libraryCallbacks,
@@ -533,6 +560,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ffiBindingSymbols: ffiValidation.symbolsByName,
             wholeSlotDegradation: true,
         });
@@ -559,10 +587,12 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
     let dynNodeStreams = reachableEmit.requiresDynNodeStreams;
     const streamPass = (dyn) => {
         const general = new Lowerer(program, entry, moduleOrder, {
+            facts,
             frontendServices: options.frontendServices,
             projectCheckJs: options.projectCheckJs ?? false,
             targetPlatform,
             startupCrash,
+            admittedOpinions: options.admittedOpinions,
             inlineRequireCycleCalls,
             dynamicImportRejections: options.dynamicImportRejections,
             ffiImports,
@@ -572,6 +602,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ffiBindingSymbols: ffiValidation.symbolsByName,
             generalNodeStreams: true,
             ...(dyn ? { dynNodeStreams: true } : {}),
@@ -604,6 +635,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
     // without such a settled fence retain checker-backed IR exactly once.
     if (resultLowerer.requiresHistoricalOrderRelower) {
         const emit = new Lowerer(program, entry, moduleOrder, {
+            facts,
             frontendServices: options.frontendServices,
             projectCheckJs: options.projectCheckJs ?? false,
             ...(generalNodeStreams ? { generalNodeStreams: true } : {}),
@@ -611,6 +643,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             reachable,
             targetPlatform,
             startupCrash,
+            admittedOpinions: options.admittedOpinions,
             inlineRequireCycleCalls,
             dynamicImportRejections: options.dynamicImportRejections,
             ffiImports,
@@ -621,6 +654,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ...(resultLowerer.wholeSlotDegradation ? { wholeSlotDegradation: true } : {}),
         });
         for (const d of extraModuleCycleDiags)
@@ -631,6 +665,20 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         resultLowerer = emit;
         timing("historical-order-relower");
     }
+    // LIBRARY mode: the profile's export names resolved to the units that
+    // supply them — the entry's own unit for a direct export, the declaring
+    // module's tagged unit for a re-exported one. The export-map resolution
+    // reads this to land each profile entry on the compiled function without
+    // assuming the entry file declared it.
+    if (options.libRoots !== undefined && options.libRoots.length > 0) {
+        const libExportUnits = new Map();
+        for (const name of options.libRoots) {
+            const unit = resultLowerer.libExportUnit(name);
+            if (unit !== null)
+                libExportUnits.set(name, unit);
+        }
+        result = { ...result, libExportUnits };
+    }
     // Divergence warnings over the program's own modules: computed once,
     // after lowering, from the same checker (never part of a failure).
     const divergences = [
@@ -741,6 +789,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
     if (options.coverage !== true)
         return result;
     const remainderPass = (general, dyn = dynNodeStreams) => new Lowerer(program, entry, moduleOrder, {
+        facts,
         frontendServices: options.frontendServices,
         projectCheckJs: options.projectCheckJs ?? false,
         ...(general ? { generalNodeStreams: true } : {}),
@@ -750,6 +799,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         alreadyFlushed: resultLowerer.flushedSymbols,
         degradedTypes: resultLowerer.degradedTypes,
         retriedSymbols: resultLowerer.retriedSymbols,
+        admittedOpinions: options.admittedOpinions,
         inlineRequireCycleCalls,
         dynamicImportRejections: options.dynamicImportRejections,
         targetPlatform,
@@ -761,6 +811,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         externalTypes,
         externalTypeSpecifiersByFile,
         tierMode,
+        runtimeOptionalReport,
     });
     let remainder = remainderPass(generalNodeStreams);
     let rem = remainder.run();
@@ -787,6 +838,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             reached: [...options.tierReport.preflight, ...result.diagnostics],
             deferred: result.runtimeFences,
             unreached: [...rem.diagnostics, ...rem.runtimeFences],
+            runtimeOptional: resultLowerer.runtimeOptionalNarrowings,
         });
     // 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);
@@ -849,7 +901,7 @@ export function staticImportNamespaceType(lowerer, expr) {
             !source.fileName.endsWith(".cts") &&
             !isCjsJsFile(source, lowerer.program) &&
             lowerer.moduleOrder.includes(source)) {
-            moduleId = `file:${tsgoPath(resolve(source.fileName))}`;
+            moduleId = `file:${lowerer.pathOf(source)}`;
         }
     }
     if (moduleId === null)
@@ -1263,7 +1315,24 @@ function builtinMemberValueName(lowerer, receiver, member) {
         return null;
     return builtinModuleFnOf(lowerer, module, member)?.valueName ?? null;
 }
+/** Whether `node` is a function, arrow or class DEFINITION that carries no
+ * name of its own, so the binding or property it initializes names it
+ * (V8's SetFunctionName). Every other expression evaluates to a value that
+ * already has whatever name it has. */
+function isAnonymousCallableDefinition(node) {
+    if (ts.isArrowFunction(node))
+        return true;
+    return (ts.isFunctionExpression(node) || ts.isClassExpression(node)) && node.name === undefined;
+}
+/** The name V8 gives a function value read from this expression: its own
+ * definition, through parenthesized, rebindable and const bindings and
+ * property reads (`process.cwd`), or the binding an anonymous definition
+ * initializes. Null when the source does not determine it. */
 export function jsFuncNameOf(node, lowerer) {
+    // Typed source cannot read a function's `name` (SC2020), so the names below
+    // are unobservable there; keeping them JavaScript-only leaves every typed
+    // program's output byte-identical.
+    const js = isJsSourceFile(ts.getSourceFileOfNode(node));
     let n = node;
     while (ts.isParenthesizedExpression(n))
         n = n.expression;
@@ -1278,14 +1347,45 @@ export function jsFuncNameOf(node, lowerer) {
             n = declaration;
             break;
         }
-        if (!declaration ||
-            !ts.isVariableDeclaration(declaration) ||
-            !declaration.initializer ||
-            (ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const) === 0)
+        // A binding element or a parameter holds the default's value only when the
+        // destructured value or the argument was undefined; otherwise it holds the
+        // source's value. Which one ran is a runtime fact, so a default never
+        // answers for the binding: when it runs, the definition it created was
+        // already named after the binding, and a named definition it references
+        // keeps the name it spells. A default the source overrides must not lend
+        // its name to the supplied value (`const [x = function unused() {}] =
+        // [function supplied() {}]` is "supplied"), so this answers null and the
+        // name read takes the runtime value's own name.
+        // Without a default the spelling is wrong for every value the binding can
+        // hold, but that shape has no pattern-default signature and is a separate
+        // change; it keeps the previous answer here.
+        if (js && declaration && (ts.isBindingElement(declaration) || ts.isParameter(declaration))) {
+            if (!declaration.initializer)
+                break;
+            return null;
+        }
+        if (!declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer)
             break;
-        n = declaration.initializer;
-        while (ts.isParenthesizedExpression(n))
-            n = n.expression;
+        let value = declaration.initializer;
+        while (ts.isParenthesizedExpression(value))
+            value = value.expression;
+        // Name inference (V8's SetFunctionName) covers an ANONYMOUS function or
+        // class definition and nothing else: the binding names it, so a
+        // rebindable binding keeps the binding's spelling below. Any other
+        // initializer is a value that carries its own name — a named
+        // definition, a builtin function (`var a = String; a.name` is
+        // "String") or another binding (`var a = b` keeps b's name) — and
+        // resolution follows it.
+        if (isAnonymousCallableDefinition(value)) {
+            // The binding this definition initializes named it when it was
+            // created, so answer that binding and not the alias the reference
+            // reached it through: `import b from "./m"` keeps the "root" of
+            // `const root = (text) => text;` in `m`.
+            if (ts.isIdentifier(declaration.name))
+                return declaration.name.text;
+            break;
+        }
+        n = value;
     }
     if (ts.isIdentifier(n))
         return n.text;
@@ -1293,7 +1393,9 @@ export function jsFuncNameOf(node, lowerer) {
         return n.name.text;
     if ((ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n)) && n.name)
         return n.name.text;
-    if (ts.isFunctionExpression(n) || ts.isArrowFunction(n)) {
+    if (ts.isClassExpression(n) && n.name)
+        return n.name.text;
+    if (ts.isFunctionExpression(n) || ts.isArrowFunction(n) || ts.isClassExpression(n)) {
         // An anonymous function takes the name of the binding or property it
         // initializes, through parentheses (`const f = (function () {})`).
         let outer = n;
@@ -1309,6 +1411,32 @@ export function jsFuncNameOf(node, lowerer) {
         if (p && ts.isPropertyAssignment(p) && p.initializer === outer && ts.isIdentifier(p.name)) {
             return p.name.text;
         }
+        // A default parameter names it (`function f(a = function () {})`), as
+        // does an object-assignment shorthand (`({ a = function () {} } = o)`)
+        // and a plain identifier assignment (`a = function () {}`). A member
+        // target never names one: only an identifier reference does.
+        if (js && p && ts.isParameter(p) && p.initializer === outer && ts.isIdentifier(p.name)) {
+            return p.name.text;
+        }
+        if (js &&
+            p &&
+            ts.isShorthandPropertyAssignment(p) &&
+            p.objectAssignmentInitializer === outer &&
+            ts.isIdentifier(p.name)) {
+            return p.name.text;
+        }
+        if (js &&
+            p &&
+            ts.isBinaryExpression(p) &&
+            p.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            p.right === outer &&
+            ts.isIdentifier(p.left) &&
+            // The native parser folds a parenthesized target into the target itself
+            // (`(a) = f`), leaving the source's `(` as a gap in front of it. A
+            // parenthesized target is not an IdentifierReference and names nothing.
+            p.getStart() === p.left.getStart()) {
+            return p.left.text;
+        }
     }
     return null;
 }
@@ -1365,6 +1493,9 @@ export class Lowerer {
     /** Per file: whether it assigns `exports` and `module.exports`
      * (cjs-exports-object.ts). */
     cjsExportsAssignments = new Map();
+    /** JavaScript checker diagnostics preflight admitted under an opinion row
+     * (LoadResult.admittedOpinions): the sites opinionAt answers for. */
+    admittedOpinions;
     /** Inline require() calls whose module edge closes a require cycle
      * (LoadResult.inlineRequireCycleCalls). */
     inlineRequireCycleCalls;
@@ -1375,6 +1506,11 @@ export class Lowerer {
      * exact binding discipline as globals/functions. */
     staticCallables = new Map();
     genericFnsBySymbol = new Map();
+    /** Temporal-dead-zone flags of module-scope generic ALIASES (`const h =
+     * id`) that code can read before the declaration runs: the alias has no
+     * binding storage of its own, so a read that can come first checks a
+     * flag instead (bindingGenericFnAliasInfoOf). */
+    genericAliasPresence = new Map();
     /** Typed declarations' instances for arguments that keep their own
      * record or array layout (structural-instances.ts). */
     structuralFnInfos = new Map();
@@ -1645,6 +1781,26 @@ export class Lowerer {
      * type parameters are bound to `unknown`, so lambdaSignature admits
      * them. */
     erasingLambdas = new Set();
+    /** Identity comparisons of a generic declaration met while lowering
+     * (directly against the declaration, or through a dynamic value): exact
+     * only while the program holds that declaration as one function object
+     * (checkGenericIdentityPins). */
+    genericIdentityPins = [];
+    /** Identity comparisons whose operands are dynamic values, recorded while
+     * lowering and resolved by checkGenericIdentityPins only when some
+     * generic declaration is held at more than one signature. */
+    dynIdentityComparisons = [];
+    /** The value instance each pinned binding holds (`const f: Fn = ident`),
+     * keyed by the binding's declaration: two pins of one generic
+     * declaration at different signatures are separate compiled closures, so
+     * checkGenericIdentityPins refuses to compare them. */
+    pinnedValueInstances = new Map();
+    /** Function-vs-function identity comparisons recorded while lowering,
+     * with the closure name each operand lowered to when it is a closure
+     * (an inline instantiation expression names its instance directly). */
+    pinnedIdentityComparisons = [];
+    /** The identity comparison check reports once, after all lowering. */
+    genericIdentityCheckDone = false;
     /** Function expressions lowered against a fixed target signature with a
      * tuple-typed `arguments` (typed-arguments.ts). */
     typedArgumentsLambdas = new Set();
@@ -1741,9 +1897,18 @@ export class Lowerer {
     streamPropMutatedSyms = null;
     /** Whether some source reads process.exitCode (processReadsExitCode). */
     readsExitCode = null;
+    /** Whether some source replaces a process output stream's write method
+     * (programPatchesStdio in builtins/process.ts). */
+    patchesStdio = null;
+    /** The write-replacement site programPatchesStdio found: the executable
+     * planner refuses it beside Node islands (SC8006). */
+    stdioPatchSites = [];
     requestInitPropMutatedSyms = null;
     emitterEventTable = null;
     emitterComputedPatterns = [];
+    /** Some site registers a listener under an unrestricted computed name
+     * (lower-event-emitter.ts emitterEvents). */
+    emitterAnyNameListener = false;
     /** The EventTarget engine's handleEvent reader was lifted
      * (lower-event-target.ts noteEventListeners). */
     handleEventReader = false;
@@ -1796,6 +1961,19 @@ export class Lowerer {
      * prepass. This includes explicit annotations: unchecked TS annotations do
      * not prove that an array property read produced a value. */
     runtimeOptionalBindingTypes = new Map();
+    /** The indexed-read analysis's storage decisions: kept for the coverage
+     * report when --explain-dynamic asks, and written to stderr under
+     * SCRIPTC_DEBUG_RUNTIME_OPTIONAL=1. */
+    runtimeOptionalProvenance;
+    /** Coverage (--explain-dynamic): the widened slots whose storage holds
+     * an absence the checker's type does not admit, with the reads that
+     * narrow them below it (runtime-optional-report.ts). Empty unless the
+     * report was asked for. */
+    runtimeOptionalNarrowings = [];
+    /** JavaScript bindings assigned values outside their declared type
+     * (analyzeJsWidenedBindings): checked-dynamic storage, and reads keep the
+     * stored value instead of narrowing it to the checker's type. */
+    jsWidenedBindings = new Set();
     /** 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
@@ -2358,6 +2536,9 @@ export class Lowerer {
     /** The collection types that uses prove for untyped JavaScript bindings,
      * by every identifier naming one (js-collection-types.ts). */
     inferredCollectionTypes = undefined;
+    /** Partial record assertions (`partial-assertions.ts`): per target shape,
+     * the required fields some asserted literal leaves unwritten. */
+    partialAssertions = undefined;
     /** overload-choice's answers per call, binding and function. */
     dynamicOverloadAnswers = new Map();
     /** Error parameters of an error-first callback with a known value in
@@ -2402,6 +2583,11 @@ export class Lowerer {
      * Reachability lowers inits before the declarations they discover, so
      * these rebuild after the worklist restores historical shape metadata. */
     shapeOrderHelperFinalizers = [];
+    /** Whether any lowered function converts a checked-dynamic value into a
+     * closed record, the only conversion that can leave a record holding
+     * undeclared source keys (record-sources.ts). Settled once lowering ends,
+     * before the shape helpers finalize their bodies. */
+    recordSourcesPossible = false;
     /** Construction witnesses that choose each shape's enumeration order
      * once lowering settles (key-order-witness.ts). */
     keyOrder = new KeyOrderNotes();
@@ -2508,6 +2694,9 @@ export class Lowerer {
      * interned here so references under one source-world ABI are the SAME
      * zero-capture closure (see primitiveCtorClosure). */
     primitiveCtorFns = new Map();
+    /** Whether a compiled source creates primitive wrapper objects
+     * (programCreatesWrappers), computed on first use. */
+    createsWrappers = undefined;
     /** Builtin-module FUNCTIONS admitted as values by their surface-table
      * entries. The resolved runtime function plus ABI is the identity key,
      * so named imports, namespace reads, CommonJS bindings, and alias chains
@@ -2515,9 +2704,16 @@ export class Lowerer {
     builtinCallableValueFns = new Map();
     /** Each builtin function-value adapter's Node name, for boxed values. */
     builtinCallableValueNames = new Map();
+    /** Adapters whose name holds on the main thread only
+     * (BuiltinModuleFn.valueNameMainThreadOnly): a Worker boxes them
+     * unnamed, as Node's unwrapped function is. */
+    builtinCallableValueMainThreadNames = new Set();
     /** Builtin function values whose `length` differs from their adapter's
      * parameter count (BuiltinModuleFn.valueLength), by adapter name. */
     builtinCallableValueLengths = new Map();
+    /** Typed builtin adapters with a checked twin (checkedBuiltinValue): the
+     * builtin, its display name and the location the twin is lowered at. */
+    builtinCheckedValues = 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
@@ -2530,6 +2726,9 @@ export class Lowerer {
     neverValued = new Set();
     chainNarrowedType = new Map();
     chainHandled = new Set();
+    /** One arm's narrowed value for a spread source while a distributed
+     * union spread lowers that arm (lowerDistributedUnionSpread). */
+    spreadArmOverrides = new Map();
     /** for-of-over-matchAll bindings whose `.index` reads the companion-index
      * array: binding SYMBOL → the hidden number[] of match start indices plus
      * the hidden cursor holding THIS iteration's position (registered while
@@ -2631,6 +2830,12 @@ export class Lowerer {
     globalsByDeclNode = new Map();
     globalsList = [];
     npmInitActions = new Map();
+    /** Per-file %init statements of static island imports and re-exports,
+     * by the import or export statement that loads the island module: the
+     * importer's %init header runs them in that statement's place among its
+     * dependencies' %init calls, so the island module evaluates in source
+     * order with the native dependencies around it. */
+    islandImportActions = new Map();
     /** Per-file %init PRELUDE statements for JSON imports: bakeable DATA
      * assignments with no observable evaluation order of their own —
      * prepended by lowerFileInit so the bindings are live before any
@@ -2707,6 +2912,9 @@ export class Lowerer {
     nodeIslandLoads = [];
     /** Island handle bindings by symbol (lower-node-island.ts). */
     islandHandleBindings = new Map();
+    /** Names a native module re-exports from an island package, by the
+     * symbol an alias chain reaches (lower-node-island.ts). */
+    islandReexports = new Map();
     /** `instanceof` expressions the island lowering already handles. */
     islandInstanceofHandled = new Set();
     /** NI-6: the modules shared with Node islands (lower-shared-modules.ts),
@@ -2728,6 +2936,28 @@ export class Lowerer {
     threadSlotFamilies = new Map();
     /** Classes used as ThreadSlots keys: their hierarchies carry a slot word. */
     threadSlotKeys = new Set();
+    /** The narrowing conversions that link copies to their sources, by
+     * `${from}:${to}` (record-links.ts). */
+    recordLinks = new Map();
+    /** Where each of recordLinks' pairs was first converted, by compose
+     * helper name. */
+    recordLinkLocs = new Map();
+    /** The conversion each %rec.string and %rec.primitive helper's calls
+     * replace, by helper name (record-links.ts recordStringCall). */
+    recordStringFallbacks = new Map();
+    /** The conversion helpers that build copies of recordLinks' pairs. */
+    recordLinkSites = [];
+    /** Object.prototype methods other than toString called by name on
+     * record types (finalizeRecordLinks checks them against link sources). */
+    recordMethodCalls = [];
+    /** Completions of "custom" linked helpers (record-links.ts), which
+     * finalizeRecordLinks runs once the links are known. */
+    linkedHelperFinalizers = [];
+    /** Helpers over record types that finalizeRecordLinks completes. */
+    linkedHelpers = [];
+    /** The JavaScript names of object literals' methods, by lifted function
+     * (function-names.ts). */
+    objectMethodNames = new Map();
     forkTargetIdByPath = new Map();
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
@@ -2791,12 +3021,63 @@ export class Lowerer {
     unions = new UnionRegistry();
     /** Context-free successful type mappings. See TypeMapperCtx.typeMemo. */
     typeMemo = new Map();
-    ambient = ambientDtsPath();
-    overridesAmbient = overridesDtsPath();
+    /** Successful mappings that read no generic-instantiation scope state
+     * (TypeMapperCtx.typeMemoShared): the same answer in every binding scope
+     * and at the top level. A generic instance's unscoped types land here, so
+     * the next instance — and the top level — answers them without mapping
+     * again. */
+    sharedTypeMemo = new Map();
+    /** Successful mappings per generic binding context (TypeMapperCtx.typeMemoFor):
+     * by the installed typeParamBindings map, then the typeParamTsBindings map
+     * (NO_BINDINGS stands for null). Binding maps are filled before they are
+     * installed and never change while installed, so their identity is the
+     * context. The lowerer owns the memos: they live as long as it does. */
+    scopedTypeMemos = new Map();
+    /** The program facts this Lowerer shares with the other passes of its
+     * island round (lowering-facts.ts). Every field that is a fact lives
+     * there, so a pass that re-derives it cannot disagree with its siblings.
+     * A Lowerer built without LowererMode.facts gets a private copy (tests,
+     * one-off lowerings). */
+    facts;
+    /** SCRIPTC_LOWERING_FACTS_VERIFY: the shared provenance memo's hit check,
+     * public so contexts built from this Lowerer (webassembly.ts's hand-made
+     * ctx, property-access.ts passing the Lowerer itself) verify too. */
+    verifySymbolProvenance;
     /** The one mapType context: registries + hooks, assembled in the
      * constructor (typeParamResolver reads the CURRENT instantiation bindings
      * through `this`, so the same ctx serves generic bodies too). */
     typeCtx;
+    /** The context lastContextMemo answered for. Every mapType call asks for the
+     * current binding context, and a lowering pass stays in one context for
+     * thousands of calls, so the pair of identity checks below is the whole
+     * cost on that path: the two-level lookup only runs when the context
+     * actually changes. */
+    lastMemoOuter = null;
+    lastMemoInner = null;
+    lastMemo = null;
+    /** The memo for the current binding context (scopedTypeMemos). */
+    currentTypeMemo() {
+        if (this.typeParamBindings === null && this.typeParamTsBindings === null)
+            return this.typeMemo;
+        const outer = this.typeParamBindings ?? NO_BINDINGS;
+        const inner = this.typeParamTsBindings ?? NO_BINDINGS;
+        if (outer === this.lastMemoOuter && inner === this.lastMemoInner)
+            return this.lastMemo;
+        let byTs = this.scopedTypeMemos.get(outer);
+        if (byTs === undefined) {
+            byTs = new Map();
+            this.scopedTypeMemos.set(outer, byTs);
+        }
+        let memo = byTs.get(inner);
+        if (memo === undefined) {
+            memo = new Map();
+            byTs.set(inner, memo);
+        }
+        this.lastMemoOuter = outer;
+        this.lastMemoInner = inner;
+        this.lastMemo = memo;
+        return memo;
+    }
     stats = {
         statementsTotal: 0,
         statementsFailed: 0,
@@ -2819,6 +3100,11 @@ export class Lowerer {
     /** Whether the program freezes, seals or prevents extensions of untyped
      * values other than fresh literals (noteUntypedIntegrity). */
     untypedIntegrity = false;
+    /** A JavaScript source constructs an ArrayBuffer with a maxByteLength,
+     * or reads a member that resizes, grows or detaches a buffer
+     * (buffers.ts, t262-dc §2.4). Sets IrModule.bytesHeadersMutable and arms
+     * the scr_js_buffers views registry in %main. */
+    buffersMutable = false;
     liftedFns = [];
     /** `for … of` and `for await` loops over untyped iterables, by their
      * generator-kind local (generator-dynamic-dispatch.ts steps the program's
@@ -2837,6 +3123,9 @@ export class Lowerer {
     /** web-streams-dyn.ts's answer: whether a JavaScript source names a web
      * stream class; undefined until asked. */
     namesWebStreamClass = undefined;
+    /** web-streams-dyn.ts's answer: whether a TypeScript source uses a web
+     * stream operation the native streams lack; undefined until asked. */
+    typedWebStreams = undefined;
     /** The first lifted function of each name (liftedFnNamed), for the
      * liftedFns indexed so far. liftedFns only grows. */
     liftedFnsByName = new Map();
@@ -2919,6 +3208,10 @@ export class Lowerer {
      * function called above the declaration statement reads that, never a
      * NULL slot. Filled by collectGlobals. */
     varGlobalEntryInits = new Map();
+    /** Initializer-less JavaScript lets holding a runtime handle or undefined
+     * that a closure captures (inferredEvolvingLetType). Reads inside a nested
+     * function lower as the checked-dynamic value. */
+    closureDynLets = new Set();
     /** Import-cycle bindings with an initialization flag, by global id, and
      * the top-level statements declaring them (cycle-initialization.ts). */
     cycleInitFlags = new Map();
@@ -3165,7 +3458,9 @@ export class Lowerer {
             mapTable("primitiveCtorFns", this.primitiveCtorFns),
             mapTable("builtinCallableValueFns", this.builtinCallableValueFns),
             mapTable("builtinCallableValueNames", this.builtinCallableValueNames),
+            setTable("builtinCallableValueMainThreadNames", this.builtinCallableValueMainThreadNames),
             countTable("builtinCallableValueLengths", this.builtinCallableValueLengths),
+            irDataTable("builtinCheckedValues", this.builtinCheckedValues),
             mapTable("regionRunHelpers", this.regionRunHelpers),
             mapTable("internTableHelpers", this.internTableHelpers),
             functionTable("liftedFns", this.liftedFns, (fn) => this.liftedFnNamed(fn) !== undefined, () => {
@@ -3201,6 +3496,7 @@ export class Lowerer {
             checkedTable("genericFnsBySymbol", () => this.genericFnsBySymbol.size),
             checkedTable("objLitGenericFns", () => this.objLitGenericFns.size),
             checkedTable("bindingGenericFns", () => this.bindingGenericFns.size),
+            checkedTable("genericAliasPresence", () => this.genericAliasPresence.size),
             checkedTable("bindingIdentifiers", () => this.bindingIdentifiers.size),
             checkedTable("ownToStringTargets", () => this.ownToStringTargets.size),
             checkedTable("neverReassignedCache", () => this.neverReassignedCache.size),
@@ -3212,6 +3508,13 @@ export class Lowerer {
             checkedTable("genericFunctionDemandOwner", () => this.genericFunctionDemandOwner.size),
             checkedTable("genericClassDemandOwner", () => this.genericClassDemandOwner.size),
             checkedTable("erasingLambdas", () => this.erasingLambdas.size),
+            checkedTable("genericIdentityPins", () => this.genericIdentityPins.length),
+            checkedTable("dynIdentityComparisons", () => this.dynIdentityComparisons.length),
+            // Pinned binding instances and function-vs-function identity
+            // comparisons feed the same end-of-lowering check; a unit that records
+            // one lowers again rather than replaying a record without it.
+            checkedTable("pinnedValueInstances", () => this.pinnedValueInstances.size),
+            checkedTable("pinnedIdentityComparisons", () => this.pinnedIdentityComparisons.length),
             checkedTable("typedArgumentsLambdas", () => this.typedArgumentsLambdas.size),
             checkedTable("tupleAliasSymbols", () => this.tupleAliasSymbols.size),
             checkedTable("nullishFuncResults", () => this.nullishFuncResults.size),
@@ -3287,6 +3590,7 @@ export class Lowerer {
             checkedTable("globalsByDeclNode", () => this.globalsByDeclNode.size),
             checkedTable("globalsList", () => this.globalsList.length),
             checkedTable("npmInitActions", () => this.npmInitActions.size),
+            checkedTable("islandImportActions", () => this.islandImportActions.size),
             checkedTable("jsonInitActions", () => this.jsonInitActions.size),
             checkedTable("jsonRequireModules", () => this.jsonRequireModules.size),
             checkedTable("jsonRequireCalls", () => this.jsonRequireCalls.size),
@@ -3306,6 +3610,14 @@ export class Lowerer {
             checkedTable("threadSlotNames", () => this.threadSlotNames.size),
             checkedTable("threadSlotFamilies", () => this.threadSlotFamilies.size),
             checkedTable("threadSlotKeys", () => this.threadSlotKeys.size),
+            checkedTable("recordLinks", () => this.recordLinks.size),
+            checkedTable("recordLinkLocs", () => this.recordLinkLocs.size),
+            checkedTable("recordLinkSites", () => this.recordLinkSites.length),
+            checkedTable("recordStringFallbacks", () => this.recordStringFallbacks.size),
+            checkedTable("linkedHelpers", () => this.linkedHelpers.length),
+            checkedTable("linkedHelperFinalizers", () => this.linkedHelperFinalizers.length),
+            checkedTable("recordMethodCalls", () => this.recordMethodCalls.length),
+            checkedTable("objectMethodNames", () => this.objectMethodNames.size),
             checkedTable("forkTargetIdByPath", () => this.forkTargetIdByPath.size),
             checkedTable("nsBlocks", () => this.nsBlocks.size),
             checkedTable("initNameOf", () => this.initNameOf.size),
@@ -3320,6 +3632,7 @@ export class Lowerer {
             checkedTable("preparedClassFactories", () => this.preparedClassFactories.size),
             checkedTable("preparingClassFactories", () => this.preparingClassFactories.size),
             checkedTable("varGlobalEntryInits", () => this.varGlobalEntryInits.size),
+            checkedTable("closureDynLets", () => this.closureDynLets.size),
             checkedTable("cycleInitFlags", () => this.cycleInitFlags.size),
             checkedTable("classInitFlags", () => this.classInitFlags.size),
             checkedTable("cycleInitDeclarations", () => this.cycleInitDeclarations.size),
@@ -3400,10 +3713,9 @@ export class Lowerer {
         // settings
         "frontendServices",
         "nodeIslands",
-        "ambient",
-        "overridesAmbient",
         "remainder",
         "tierMode",
+        "runtimeOptionalReport",
         "generalNodeStreams",
         "dynNodeStreams",
         "targetPlatform",
@@ -3414,10 +3726,12 @@ export class Lowerer {
         "priorRetriedSymbols",
         "wholeSlotDegradation",
         "inferredCollectionTypes",
+        "partialAssertions",
         "foreignElementKeys",
         // caches made when first needed
         "nanCodedReads",
         "mentionsProcessVersions",
+        "createsWrappers",
         "stringIndexBoundsCache",
         "functionLocalSubclasses",
         "socketEncodingReachable",
@@ -3425,8 +3739,32 @@ export class Lowerer {
         "unixListenReachable",
         "streamPropMutatedSyms",
         "readsExitCode",
+        "patchesStdio",
+        "stdioPatchSites",
         "requestInitPropMutatedSyms",
-        "classProtocols",
+        // Program facts the round's passes share (lowering-facts.ts): file
+        // paths, stdlib/external/package classification, a symbol's declared
+        // provenance, the island-handle answers, the admitted-opinion index,
+        // the JavaScript dynamic-declaration set and the class protocol index.
+        // They are pure functions of (program, island set, external surface),
+        // so no pass's mode can change them, and each is verified against a
+        // fresh computation under SCRIPTC_LOWERING_FACTS_VERIFY.
+        "facts",
+        // SCRIPTC_LOWERING_FACTS_VERIFY only: this pass's own class protocol
+        // index and provenance hit check, the comparisons the shared answers
+        // are checked against.
+        "ownClassProtocols",
+        "verifySymbolProvenance",
+        // The whole-program prepass analyzeJsWidenedBindings computes this set
+        // before lowering begins: a pure function of the program's modules.
+        "jsWidenedBindings",
+        // Preflight's admitted opinions are a program fact computed before any
+        // unit lowers.
+        "admittedOpinions",
+        // Coverage's --explain-dynamic report: the indexed-read analysis's
+        // storage decisions and the narrowed reads they explain.
+        "runtimeOptionalProvenance",
+        "runtimeOptionalNarrowings",
         "cjsSplitRequireBindings",
         "cjsWholeExportSymbols",
         "cjsLiveMemberExports",
@@ -3437,24 +3775,33 @@ export class Lowerer {
         "sloppyThisGlobalReads",
         "globalLookupNames",
         "namesWebStreamClass",
+        "typedWebStreams",
         "timeValueDateDecisions",
         "timeValueDateWrites",
         "dynamicOverloadAnswers",
         "argumentCountSlots",
         "coercions.widenedReturnTypes",
-        "packageFileMemo",
+        // LIBRARY mode: the unit each root export name seeds is a pure function
+        // of the entry's export table and the signatures collected before any
+        // body lowers, so a pass that asks again computes the same answer.
+        "libExportUnits",
         // NI-5: whether a symbol names an island handle binding depends only on
         // its declaration, so the answer is a memo keyed by symbol.
         "islandHandleBindings",
+        // The island names native modules re-export: a pure function of the
+        // program's modules, collected before lowering begins.
+        "islandReexports",
         // The modules shared with the islands (NI-6): a pure function of the
         // program's modules, computed once, and the TDZ flags its plan gives a
         // statement.
         "sharedModules",
         "sharedInitFlags",
+        // Settled from every lowered function once lowering ends, before the
+        // shape helpers finalize (record-sources.ts).
+        "recordSourcesPossible",
         "slotOriginMemo",
         "recordOriginMemo",
         "boundaryCastOrder",
-        "declBoundaryMemo",
         "structuredCloneReadCounts",
         // state of the unit being lowered
         "assertedValues",
@@ -3508,8 +3855,14 @@ export class Lowerer {
         "neverValued",
         "chainNarrowedType",
         "chainHandled",
+        "spreadArmOverrides",
         "splitIdentifierUses",
         "typeMemo",
+        "sharedTypeMemo",
+        "scopedTypeMemos",
+        "lastMemoOuter",
+        "lastMemoInner",
+        "lastMemo",
         "fnStack",
         "positions.nodesByKey",
         "positions.paths",
@@ -3538,14 +3891,19 @@ export class Lowerer {
             flag("cjsModuleGraphEnabled", () => this.cjsModuleGraphEnabled, () => (this.cjsModuleGraphEnabled = true)),
             flag("globalThisComputedWrite", () => this.globalThisComputedWrite, () => (this.globalThisComputedWrite = true)),
             flag("untypedIntegrity", () => this.untypedIntegrity, () => (this.untypedIntegrity = true)),
+            flag("buffersMutable", () => this.buffersMutable, () => (this.buffersMutable = true)),
             flag("partialDegradedTypesMapped", () => this.partialDegradedTypesMapped, () => (this.partialDegradedTypesMapped = true)),
             fixed("errorAccessorReflection", () => this.errorAccessorReflection),
             fixed("subclassLinks", () => this.subclassLinks),
             fixed("errorPathCopies", () => this.errorPathCopies),
+            // A latch of the end-of-lowering audit (checkGenericIdentityPins): a
+            // unit never touches it.
+            fixed("genericIdentityCheckDone", () => this.genericIdentityCheckDone),
             fixed("errorMethodDispatchRevision", () => this.errorMethodDispatchRevision),
             fixed("errorPropertyDispatchRevision", () => this.errorPropertyDispatchRevision),
             fixed("childAdditions", () => this.childAdditions),
             fixed("emitterEventTable", () => this.emitterEventTable),
+            fixed("emitterAnyNameListener", () => this.emitterAnyNameListener),
             fixed("globalThisWrittenNames", () => this.globalThisWrittenNames),
             fixed("importRetryModules", () => this.importRetryModules),
             fixed("localSubclassIndex", () => this.localSubclassIndex),
@@ -3591,6 +3949,8 @@ export class Lowerer {
      * refuse and fence exactly as before. Stage S6 demotes the units of
      * committed refusals in "auto" and keeps them refusals in "static-only". */
     tierMode;
+    /** LowererMode.runtimeOptionalReport. */
+    runtimeOptionalReport;
     generalNodeStreams;
     dynNodeStreams;
     /** Functions finishModule placed in the dynamic tier (ir/tiers.ts). */
@@ -3768,7 +4128,6 @@ export class Lowerer {
      * (decl-origin.ts), by IrModule.declOrigins index. */
     declOrigins = [];
     declOriginIds = new Map();
-    packageFileMemo = new Map();
     slotOriginMemo = new Map();
     /** The value whose slot coercion is being lowered, while that value is
      * in a package file: union extractions built for it carry the slot's
@@ -3824,18 +4183,10 @@ export class Lowerer {
         return origin;
     }
     inPackageFileOf(node) {
-        const sf = ts.getSourceFileOfNode(node);
-        let inside = this.packageFileMemo.get(sf);
-        if (inside === undefined) {
-            inside = inPackageFile(node);
-            this.packageFileMemo.set(sf, inside);
-        }
-        return inside;
+        return this.facts.inPackageFile(node);
     }
-    declBoundaryMemo = null;
     get declBoundary() {
-        this.declBoundaryMemo ??= this.program.getSourceFileNames().some(isDeclBoundaryFile);
-        return this.declBoundaryMemo;
+        return this.facts.declBoundary;
     }
     /** Tracked classes' bag initializers over a typed `this`
      * (class-dynamic-dispatch.ts recordBagInitializers). */
@@ -3861,6 +4212,7 @@ export class Lowerer {
         this.ffiImports = mode.ffiImports ?? [];
         this.forkTargets = mode.forkTargets ?? [];
         this.frontendServices = mode.frontendServices;
+        this.admittedOpinions = mode.admittedOpinions ?? [];
         this.inlineRequireCycleCalls = mode.inlineRequireCycleCalls ?? new Set();
         this.dynamicImportRejections = mode.dynamicImportRejections ?? new Map();
         this.libraryCallbacks = mode.libraryCallbacks ?? false;
@@ -3870,6 +4222,10 @@ export class Lowerer {
         this.startupCrash = mode.startupCrash ?? null;
         this.targetPlatform = mode.targetPlatform ?? process.platform;
         this.tierMode = mode.tierMode ?? "auto";
+        this.runtimeOptionalReport = mode.runtimeOptionalReport === true;
+        this.runtimeOptionalProvenance = this.runtimeOptionalReport
+            ? RuntimeOptionalProvenance.forReport()
+            : RuntimeOptionalProvenance.fromEnvironment();
         this.generalNodeStreams = mode.generalNodeStreams ?? false;
         this.dynNodeStreams = this.generalNodeStreams && (mode.dynNodeStreams ?? false);
         this.workerTargets = mode.workerTargets ?? [];
@@ -3882,13 +4238,20 @@ export class Lowerer {
         this.ffiImportsByName = new Map(this.ffiImports.map((entry) => [entry.name, entry]));
         this.externalTypeSpecifiersByFile =
             mode.externalTypeSpecifiersByFile ?? directExternalTypeSpecifiersByFile(this.externalTypes);
+        this.facts =
+            mode.facts ?? new LoweringFacts(program, moduleOrder, this.externalTypeSpecifiersByFile);
+        // A shared fact would be a silent miscompile if it described another
+        // program: the round hands every pass its own program and moduleOrder.
+        if (this.facts.program !== program || this.facts.moduleOrder !== moduleOrder)
+            throw new InternalCompilerError("lowerer bug: LowererMode.facts belongs to a different program or moduleOrder");
+        this.verifySymbolProvenance = this.facts.verify
+            ? (sym, answer) => this.verifySymbolProvenanceAnswer(sym, answer)
+            : undefined;
         this.checker = program.getTypeChecker();
         const islands = this.nodeIslands;
         const shadow = canonShadowHook(this.checker);
         this.typeCtx = {
-            ...(islands !== null
-                ? { foreignType: (t) => isForeignType(islands, t, this.checker) }
-                : {}),
+            ...(islands !== null ? { foreignType: (t) => this.foreignType(t) } : {}),
             checker: this.checker,
             positionOf: (node) => this.positions.of(node),
             shapes: this.shapes,
@@ -3924,7 +4287,7 @@ export class Lowerer {
             genericClassInstance: (decl, ref, mapArgument) => this.genericClassInstanceType(decl, ref, mapArgument),
             runtimeClassValue: (type) => runtimeClassValueOfType(this, type),
             localClassValue: (type) => this.instanceResultClass !== null && this.instanceResultClass.declared === type.id
-                ? this.instanceResultClass.value
+                ? (noteScopeSensitiveMapping(), this.instanceResultClass.value)
                 : (this.localClassValueTypes.get(type.id) ?? null),
             mixinClassInstance: (decl) => this.mixinTypeContext && this.mixinTypeContext.classNode === decl
                 ? { kind: "object", className: this.mixinTypeContext.className }
@@ -3935,6 +4298,11 @@ export class Lowerer {
                 const instanceClass = instanceType && this.localClassInstanceTypes.get(instanceType.id);
                 if (instanceClass)
                     return { kind: "object", className: instanceClass };
+                // The instantiation-stack check below (and classNamer) answers
+                // differently inside a generic instance, so this mapping stays in
+                // its scope.
+                if (this.classInsideFunction(decl))
+                    noteScopeSensitiveMapping();
                 // 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.
@@ -3982,18 +4350,28 @@ export class Lowerer {
             mixinIntersectionInstance: (widened) => mixinIntersectionInstanceType(this, widened),
             classImplementedProtocol: (type) => this.classImplementedProtocol(type),
             isStdlibFile: (sf) => this.isStdlibFile(sf),
+            primitiveWrappers: () => (this.createsWrappers ??= programCreatesWrappers(this)),
             isNpmFile: (sf) => this.isNpmFile(sf),
             isExperimentalFile: (sf) => isExperimentalDeclarationFile(sf, this.experimentalFiles),
             // The declaration-typed boundary's generated types (decl-projection.ts)
             // describe data, like an explicitly mapped external type surface.
-            isExternalTypeFile: (sf) => this.externalTypeSpecifiersByFile.has(tsgoPath(resolve(sf.fileName))) ||
-                isDeclBoundaryFile(sf.fileName),
+            isExternalTypeFile: this.isExternalTypeFile,
+            symbolProvenance: this.symbolProvenance,
+            ...(this.verifySymbolProvenance
+                ? { verifySymbolProvenance: this.verifySymbolProvenance }
+                : {}),
             typeMemo: this.typeMemo,
+            // A hook: the ctx is spread in several places, and a copy made inside a
+            // binding scope must follow the lowerer's CURRENT scope, not the one
+            // that was installed at spread time.
+            typeMemoFor: () => this.currentTypeMemo(),
+            typeMemoShared: this.sharedTypeMemo,
             ...(this.generalNodeStreams ? { generalNodeStreams: true } : {}),
             ...(this.dynNodeStreams ? { dynNodeStreams: true } : {}),
-            canMemoizeType: () => this.typeParamBindings === null &&
-                this.typeParamTsBindings === null &&
-                this.mixinTypeContext === null,
+            // Memoization is scoped by the binding maps (typeMemoFor); only a mixin
+            // context opts out, because mixinClassInstance answers by class node and
+            // the bindings do not identify it.
+            canMemoizeType: () => 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),
@@ -4028,7 +4406,7 @@ export class Lowerer {
         }
         if (this.moduleOrder.length === 0)
             this.fileTag.set(entry, "");
-        const jsDynamic = jsDynamicDeclarations(this.moduleOrder, this.checker);
+        const jsDynamic = this.facts.jsDynamicDeclarations();
         if (jsDynamic.size > 0)
             this.typeCtx.jsDynamicDeclaration = (decl) => jsDynamic.has(decl);
         this.registerBuiltinErrorClasses();
@@ -4036,6 +4414,27 @@ export class Lowerer {
         registerBuiltinStreamClasses(this);
         registerBuiltinEventTargetClasses(this);
     }
+    /** Whether preflight admitted the checker diagnostic `code` at `node`: a
+     * site in `admittedOpinions` (tsc-codes.ts, JS_OPINIONS) whose span the
+     * node contains. A `widen`/`throw`/`island` row's lowering path is reached
+     * only through this query, so a program that admitted no such site keeps
+     * the IR it has today. */
+    opinionAt(node, code) {
+        if (this.admittedOpinions.length === 0)
+            return false;
+        const file = ts.getSourceFileOfNode(node).fileName;
+        const start = ts.tokenStartOfNode(node);
+        const hit = this.admittedOpinionSites();
+        const list = hit.get(`${file}\0${code}`);
+        if (list === undefined)
+            return false;
+        return list.some((site) => start <= site.pos && site.end <= node.end);
+    }
+    /** opinionAt's index: admitted sites by file and code (one index per
+     * admitted-opinions list, shared by the round). */
+    admittedOpinionSites() {
+        return this.facts.opinionIndex(this.admittedOpinions);
+    }
     /** 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. */
@@ -4050,17 +4449,32 @@ export class Lowerer {
     registerBuiltinErrorClasses() {
         return registerBuiltinErrorClasses(this);
     }
-    classProtocols = null;
     classImplementedProtocol(type) {
-        this.classProtocols ??= new ClassProtocols(this.checker, this.moduleOrder);
-        return this.classProtocols.usesCheckedIdentity(type);
+        return this.verifyProtocol("usesCheckedIdentity", type, (protocols) => protocols.usesCheckedIdentity(type));
     }
     /** A record view a Map or Set answers: it keeps protocol identity but
      * calls the collection's own methods, never a stored member. */
     classCollectionView(type) {
-        this.classProtocols ??= new ClassProtocols(this.checker, this.moduleOrder);
-        return this.classProtocols.collectionView(type);
-    }
+        return this.verifyProtocol("collectionView", type, (protocols) => protocols.collectionView(type));
+    }
+    /** The round's shared class protocol index (lowering-facts.ts): a pure
+     * analysis of (checker, moduleOrder). With SCRIPTC_LOWERING_FACTS_VERIFY
+     * this Lowerer builds its own index and every answer is compared. */
+    verifyProtocol(query, type, ask) {
+        const answer = ask(this.facts.classProtocols());
+        if (!this.facts.verify)
+            return answer;
+        if (this.ownClassProtocols === null) {
+            this.ownClassProtocols = new ClassProtocols(this.checker, this.moduleOrder);
+        }
+        const fresh = ask(this.ownClassProtocols);
+        this.facts.noteVerified("classProtocols");
+        if (answer === fresh)
+            return answer;
+        throw new InternalCompilerError(`shared class protocol index answered ${String(answer)} for ${query} where a fresh ` +
+            `index over the same program answered ${String(fresh)}`);
+    }
+    ownClassProtocols = null;
     /** Declared class fields may store a DYN value only when its static type
      * is `unknown` or `object` (also with `null` or `undefined`, or an array
      * of those), names checked protocol identity, is an owned runtime
@@ -4077,15 +4491,40 @@ export class Lowerer {
             this.weakCollectionType(type) ||
             this.stdlibHandleType(type, (part) => isEcdhType(this, part) || isDiffieHellmanType(this, part)));
     }
-    /** A stdlib WeakMap or WeakSet, alone or with `null`/`undefined`. */
+    /** A stdlib WeakMap or WeakSet, alone or in a union with `null`/`undefined`
+     * (including the `WeakMap | WeakSet` pair). */
     weakCollectionType(type) {
+        return this.weakCollectionNamesOf(type) !== null;
+    }
+    /** The stdlib collections a type denotes — `WeakMap`, `WeakSet`, or the
+     * two in a union — alone or with `null`/`undefined`, which `nullable`
+     * reports; null for everything else. The predicate behind
+     * weak-collection lowering and the JavaScript value read of one of
+     * their methods, whose receiver may hold either collection. */
+    weakCollectionNamesOf(type) {
+        const names = [];
         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))));
+            if (symbol === undefined)
+                return false;
+            const symbolName = ts.symbolName(symbol);
+            if (symbolName !== "WeakMap" && symbolName !== "WeakSet")
+                return false;
+            if (!symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && this.isStdlibFile(ts.getSourceFileOfNode(d))))
+                return false;
+            if (!names.includes(symbolName))
+                names.push(symbolName);
+            return true;
+        };
+        if (!this.stdlibHandleType(type, weak))
+            return null;
+        return {
+            names,
+            nullable: type.isUnionType() &&
+                ts
+                    .constituentTypes(type)
+                    .some((part) => (part.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0),
         };
-        return this.stdlibHandleType(type, weak);
     }
     /** A type `handle` accepts, alone or with `null`/`undefined`. */
     stdlibHandleType(type, handle) {
@@ -4123,7 +4562,7 @@ export class Lowerer {
                 !decl.fileName.endsWith(".cts") &&
                 !isCjsJsFile(decl, this.program) &&
                 this.moduleOrder.includes(decl)) {
-                return `file:${tsgoPath(resolve(decl.fileName))}`;
+                return `file:${this.pathOf(decl)}`;
             }
             if (ts.isModuleDeclaration(decl) && ts.isStringLiteral(decl.name)) {
                 const builtin = canonicalBuiltinModule(decl.name.text);
@@ -4269,6 +4708,11 @@ export class Lowerer {
      * program-unique through the file qualifier, and collision-free with
      * user identifiers ('%'). */
     classNamer = (decl) => {
+        // A class declared inside a function takes the instantiated owner's name
+        // (`%<instance>`, below), so its type's answer is per instance — and a
+        // mapping that reads it may not be shared between scopes.
+        if (this.classInsideFunction(decl))
+            noteScopeSensitiveMapping();
         const name = ts.isClassExpression(decl) ||
             (() => {
                 for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
@@ -4288,6 +4732,16 @@ export class Lowerer {
         }
         return name;
     };
+    /** True for a class declaration lexically inside a function: only such a
+     * class can take an instantiated owner's name (classNamer), and only there
+     * can localClassInstance's instantiation-stack check answer. */
+    classInsideFunction(decl) {
+        for (let parent = decl.parent; parent !== undefined && !ts.isSourceFile(parent); parent = parent.parent) {
+            if (ts.isFunctionLike(parent))
+                return true;
+        }
+        return false;
+    }
     /** Follows import aliases to the original declaration's symbol. Every
      * value reference resolves through here, so it doubles as the flush
      * point for deferred collection diagnostics: resolving a reference to a
@@ -5400,8 +5854,71 @@ export class Lowerer {
             }
         }
     }
+    /** A JavaScript `let`/`var` binding assigned a value its declared type
+     * does not admit (`let t = parseInt(s); if (isNaN(t)) t = undefined`):
+     * TypeScript types the binding from its initializer and reports the
+     * assignment (TS2322), which JavaScript files relax, so the binding takes
+     * checked-dynamic storage and holds whatever the program stores. JSDoc
+     * type annotations keep their declared storage.
+     *
+     * A set accessor's unannotated parameter joins them: a JavaScript setter's
+     * parameter is whatever the caller passes, and `paramShape` gives the slot
+     * checked-dynamic storage. The checker types it from the twin getter's
+     * return when one exists (`set value(next) { this.stored = next; }` beside
+     * `get value() { return this.stored; }` types `next` as the getter's type),
+     * and otherwise reports TS7032; reading the parameter at the inferred type
+     * would check the caller's value back into it and throw where Node stores
+     * it as is. A JSDoc `@param` type keeps its declared storage, exactly like
+     * a variable's `@type`. */
+    analyzeJsWidenedBindings(parts) {
+        for (const { sf } of parts) {
+            if (!isJsSourceFileName(sf.fileName) || sf.isDeclarationFile)
+                continue;
+            ts.walkPreorder(sf, (node) => {
+                if (ts.isParameter(node) &&
+                    ts.isSetAccessorDeclaration(node.parent) &&
+                    !node.type &&
+                    ts.isIdentifier(node.name) &&
+                    !hasJsSetterParamAnnotation(node)) {
+                    const setterParam = this.resolveValueSymbol(node.name);
+                    if (setterParam)
+                        this.jsWidenedBindings.add(setterParam);
+                    return undefined;
+                }
+                if (!ts.isBinaryExpression(node) ||
+                    node.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+                    !ts.isIdentifier(node.left))
+                    return undefined;
+                const symbol = this.resolveValueSymbol(node.left);
+                if (!symbol || this.runtimeOptionalBindingTypes.has(symbol))
+                    return undefined;
+                const decl = symbol.valueDeclaration;
+                if (decl === undefined ||
+                    !ts.isVariableDeclaration(decl) ||
+                    !ts.isIdentifier(decl.name) ||
+                    !isJsSourceFileName(ts.getSourceFileOfNode(decl).fileName) ||
+                    hasJsTypeAnnotation(decl) ||
+                    decl.parent === undefined ||
+                    !ts.isVariableDeclarationList(decl.parent) ||
+                    (decl.parent.flags & ts.NodeFlags.Const) !== 0)
+                    return undefined;
+                const declared = this.checker.getTypeOfSymbol(symbol);
+                if (declared.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))
+                    return undefined;
+                const assigned = this.checker.getTypeAtLocation(node.right);
+                if (this.checker.isTypeAssignableTo(assigned, declared))
+                    return undefined;
+                this.runtimeOptionalBindingTypes.set(symbol, DYN);
+                this.jsWidenedBindings.add(symbol);
+                const global = this.globalsBySymbol.get(symbol);
+                if (global)
+                    global.type = DYN;
+                return undefined;
+            });
+        }
+    }
     analyzeRuntimeOptionalArrayReads(parts) {
-        const provenance = RuntimeOptionalProvenance.fromEnvironment();
+        const provenance = this.runtimeOptionalProvenance;
         // The site whose value the current promotion follows (debug only).
         let provenanceSite;
         const optionalSymbols = new Set();
@@ -5714,19 +6231,31 @@ export class Lowerer {
         };
         /** `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)
+            // A name that resolves to a declared member is a member read, and only
+            // a receiver with an index signature maps to an indexed record. The
+            // name's own symbol separates the two spellings: a mapped
+            // `Record<string, V>` answers no declaration at all, while a named
+            // object type answers the index signature's symbol, whose declaration
+            // is that signature. Reading the receiver's type instead would ask the
+            // checker about a node inside a body lowered only for coverage, which
+            // the batch prefetch covers and an extra individual query does not.
+            const nameSymbol = symbolOf(e.name);
+            const answersIndexSignature = nameSymbol === null ||
+                (nameSymbol.declarations ?? []).some((decl) => ts.isIndexSignatureDeclaration(decl));
+            if (!answersIndexSignature)
                 return false;
-            const receiver = this.mapTypeOf(receiverType);
+            const receiver = this.mapTypeOf(this.typeOf(e.expression));
             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;
+            // A slot whose value type already admits undefined tells the checker
+            // itself that a key can be missing (`{ [name: string]: string |
+            // undefined }` in the http-header shape), so the read hides nothing.
+            if (shape.indexValue.kind === "union" &&
+                this.armTag(shape.indexValue.unionId, UNDEFINED_T) >= 0)
+                return false;
             if (shape.fields.some((field) => field.name === e.name.text))
                 return false;
             const read = this.mapTypeOf(this.typeOf(e));
@@ -8288,6 +8817,11 @@ export class Lowerer {
             }
         }
         provenance?.flush();
+        // Coverage (--explain-dynamic): the slots the analysis widened past the
+        // checker's type, with the reads that narrow them back and the
+        // decisions that widened them. Report-only; lowering does not read it.
+        if (this.runtimeOptionalReport)
+            this.runtimeOptionalNarrowings = runtimeOptionalNarrowings(this, sourceFiles);
     }
     run() {
         const parts = this.splitFiles();
@@ -8309,6 +8843,7 @@ export class Lowerer {
             this.analyzeRuntimeOptionalArrayReads(parts);
             this.analyzeDateJsonResults(parts);
             this.analyzeGuardedRecordReadGlobals(parts);
+            this.analyzeJsWidenedBindings(parts);
         });
         // Decorated classes analyze AFTER the whole collection pass: a
         // decorator's return type may name a subclass declared below the
@@ -8466,9 +9001,12 @@ export class Lowerer {
         // array-HOF loop functions, which ride the same list), and the
         // implicit-any instances lowered eagerly at their first call sites.
         this.settleSharedHelperLocations([...functions, ...this.liftedFns, ...this.implicitFns]);
-        functions.push(...this.liftedFns);
-        functions.push(...this.implicitFns);
-        functions.push(...runtimeClassConstructs(this, functions));
+        for (const fn of this.liftedFns)
+            functions.push(fn);
+        for (const fn of this.implicitFns)
+            functions.push(fn);
+        for (const fn of runtimeClassConstructs(this, functions))
+            functions.push(fn);
         if (this.remainder) {
             // Deferred collection diagnostics nothing flushed — declarations no
             // reference ever made relevant. They belong to the unreached group
@@ -8479,6 +9017,9 @@ export class Lowerer {
                 for (const d of [...diags])
                     this.pushDiag(d);
             }
+            // Coverage visits more bodies; more value instances can only add
+            // refusals to the identity comparison check.
+            checkGenericIdentityPins(this);
             return {
                 module: null,
                 diagnostics: this.diags,
@@ -8491,12 +9032,25 @@ export class Lowerer {
         return this.finishModule(functions);
     }
     /** Final retention, pruning, and module assembly shared by ordinary emit
-     * and the retained reachability worklist. */
-    finishModule(functions) {
+     * and the retained reachability worklist. `library` is true for a native
+     * library's emit, whose runtime has no builtin-statics unit. */
+    finishModule(functions, library = false) {
+        // Every instance of every generic value is known now (the
+        // monomorphization worklists drained): an identity comparison against
+        // one is exact only if the declaration is held at a single signature.
+        checkGenericIdentityPins(this);
+        finalizeRecordLinks(this, functions);
+        // The statics lookup installs before value boxing, so the function
+        // values it adds to the entry module are boxed with the rest.
+        if (!library)
+            installBuiltinStatics(this, functions);
+        boxBuiltinValuesChecked(this, functions);
+        finalizeFunctionNames(this, functions);
         if (this.diags.length === 0)
             fuseArrayPipelines(this, functions);
         finalizeClassMethodValues(this, functions);
         finalizePrivateBrands(this, functions);
+        routeWrapperConsumers(this, functions);
         trackClassFieldCreation(this, functions);
         boxClassInstancesExactly(this, functions);
         addUntypedIntegrityWords(this);
@@ -8504,6 +9058,9 @@ export class Lowerer {
         guardFrozenWrites(this, functions);
         applyHandleProperties(this, functions);
         installBufferValue(functions);
+        // A mutable-buffers program arms the views registry before any buffer
+        // exists, so every buffer in it is detachable from the start.
+        const buffersMutable = this.buffersMutable && installMutableBuffersArm(functions);
         installFetchBodyWebStreams(this, functions);
         returnDispatchReceivers(this, functions);
         // Globals typed by a class that never REGISTERED (a JS class whose
@@ -8626,10 +9183,12 @@ export class Lowerer {
                 ...(this.threadSlotKeys.size > 0
                     ? { threadSlotKeys: [...this.threadSlotKeys].sort() }
                     : {}),
+                ...(this.recordLinks.size > 0 ? { recordLinks: [...this.recordLinks.values()] } : {}),
                 ...(this.freezableArrays.size > 0
                     ? { freezableArrays: [...this.freezableArrays].sort() }
                     : {}),
                 ...(this.untypedIntegrity ? { untypedIntegrity: true } : {}),
+                ...(buffersMutable ? { bytesHeadersMutable: true } : {}),
                 ...(sloppyDynWrites.length > 0 ? { sloppyDynWrites } : {}),
                 ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
@@ -8653,11 +9212,19 @@ export class Lowerer {
         // becomes its js twin), so coverage's dynamic statements are unchanged.
         if (module && this.dynamicFunctions.length > 0)
             promoteJsvals(module);
+        // A program that replaces a process output stream's write method beside
+        // Node islands is refused by the executable planner (SC8006): an
+        // island's process.stdout is its own object. Only island builds pay for
+        // the whole-program scan.
+        const stdioPatches = this.nodeIslands !== null && programPatchesStdio(this)
+            ? [...this.stdioPatchSites]
+            : undefined;
         return {
             module,
             diagnostics: this.diags,
             runtimeFences: this.runtimeFences,
             stats: this.stats,
+            ...(stdioPatches !== undefined && stdioPatches.length > 0 ? { stdioPatches } : {}),
             ...(this.dynamicFunctions.length > 0 ? { dynamicFunctions: this.dynamicFunctions } : {}),
             ...(this.statsByFile.size > 0 ? { statsByFile: this.statsByFile } : {}),
             ...(this.provenanceElided.length > 0 ? { provenanceElided: this.provenanceElided } : {}),
@@ -8760,11 +9327,14 @@ export class Lowerer {
     reportBlockedBody(decl) {
         const diags = blockedBodyDiagnostics(this, decl);
         const symbol = declSymbolOf(this, decl);
-        if (symbol && this.alreadyFlushed.has(symbol))
-            this.reachedBlockedBodyDiagnostics.push(...diags);
-        else
+        if (symbol && this.alreadyFlushed.has(symbol)) {
+            for (const d of diags)
+                this.reachedBlockedBodyDiagnostics.push(d);
+        }
+        else {
             for (const d of diags)
                 this.pushDiag(d);
+        }
     }
     /** Whether run() counts a signature-blocked declaration in
      * stats.functionsSkipped: whole-program passes and the coverage
@@ -8774,6 +9344,42 @@ export class Lowerer {
         return this.reachable === null || this.remainder;
     }
     /* ── reachability ─────────────────────────────────────────────────── */
+    /** LIBRARY mode: the unit the root name `name` seeds, resolved through
+     * the entry module's export table. A direct `export function f` and every
+     * facade that names it (`export { f }`, `export { f as g }`,
+     * `export { f } from "./m"`, `export * from "./m"`) reach the same
+     * declaration, and the unit is whatever the declaration's own module
+     * qualified it as — the entry's bare name or another module's `%mN.` tag.
+     * Memoized: the four emit passes and the result's export map read one
+     * answer. Null when the name is not an export of a compiled function
+     * (SC4002/SC4004/SC4007 report it). */
+    libExportUnit(name) {
+        const memo = this.libExportUnits;
+        if (memo.has(name))
+            return memo.get(name);
+        const symbol = resolveEntryExportSymbol(this.checker, this.entry, name);
+        let unit = null;
+        if (symbol !== null) {
+            unit = this.fnSigsBySymbol.get(symbol)?.name ?? null;
+            if (unit === null) {
+                // The export table's symbol can be a copy of the declaration's; the
+                // declaration's own symbol is the one signatures are keyed by.
+                for (const declaration of symbol.declarations) {
+                    if (!ts.isFunctionDeclaration(declaration))
+                        continue;
+                    const declared = declSymbolOf(this, declaration);
+                    unit = declared === undefined ? null : (this.fnSigsBySymbol.get(declared)?.name ?? null);
+                    if (unit !== null)
+                        break;
+                }
+            }
+        }
+        memo.set(name, unit);
+        return unit;
+    }
+    /** One answer per root name: a pass builds its own Lowerer, and the
+     * signatures this reads are collected before any body is lowered. */
+    libExportUnits = new Map();
     /** Reachable emit: computes the set of body names the program's entry
      * reaches and retains each body IR as it lowers. Seeds are the per-file
      * init bodies (top-level statements always run); edges fire from
@@ -8787,7 +9393,7 @@ export class Lowerer {
      * demand-driven) and lifted lambdas lower inline with their enclosing
      * body; both fire edges through the same hooks and are not units
      * themselves. */
-    emitReachable(extraRoots) {
+    emitReachable(extraRoots, unitStore = null) {
         // Frontend passes below rewrite function bodies through the IR mapper
         // (caught-value and class dispatch); key-order notes follow the record
         // literals they rebuild until the witness pass has read them.
@@ -8817,23 +9423,47 @@ export class Lowerer {
             collectionEdges.add(name);
         };
         this.prefetchProgramSymbols(parts);
-        this.collectProgram(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.
-        for (const info of this.classes.values())
-            analyzeClassDecoration(this, info);
-        this.prepareModuleInits(parts);
-        prepareCjsModuleGraph(this, parts);
+        // Collection poisons the pass the way statement lowering does: a Node
+        // island module the build cannot ship pushes its diagnostic (SC8006)
+        // and aborts (nodeIslandModules.addLoaded, lower-node-island.ts). The
+        // diagnostic is the report, and emission must not run on a program
+        // collected halfway, so the pass ends here with it. A poison nothing
+        // reported is still a bug and stays a crash.
+        try {
+            this.collectProgram(parts);
+            this.speculativeTypeQueries(() => {
+                extendAssertedRecordMembers(this, parts.map((fp) => fp.sf));
+                this.analyzeRuntimeOptionalArrayReads(parts);
+                this.analyzeDateJsonResults(parts);
+                this.analyzeGuardedRecordReadGlobals(parts);
+                this.analyzeJsWidenedBindings(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.
+            for (const info of this.classes.values())
+                analyzeClassDecoration(this, info);
+            this.prepareModuleInits(parts);
+            prepareCjsModuleGraph(this, parts);
+        }
+        catch (e) {
+            if (!(e instanceof PoisonError) || this.diags.length === 0)
+                throw e;
+            return {
+                reachable: collectionEdges,
+                result: {
+                    module: null,
+                    diagnostics: this.diags,
+                    runtimeFences: this.runtimeFences,
+                    stats: this.stats,
+                },
+            };
+        }
         // Every lowerable body, by emitted-function name. The names double as
         // retained-function keys and are deterministic by construction
         // (qualified declaration names).
+        // `source` is the declaration whose text a unit lowers and `owners` the
+        // declarations around it (unit-reuse.ts).
         const units = new Map();
         // Roots are collected with plain pushes: spread arguments into a rest
         // parameter pass the nodes as dynamic values.
@@ -8884,6 +9514,7 @@ export class Lowerer {
                         order: unitOrder++,
                         roots: functionRoots(decl),
                         lower: () => this.lowerFunction(decl),
+                        source: decl,
                     });
                 }
             }
@@ -8906,6 +9537,7 @@ export class Lowerer {
                     order: unitOrder++,
                     roots: classCtorRoots(info),
                     lower: () => info.localClass && !info.localClass.ready ? null : this.lowerClassCtor(info),
+                    source: info.decl ?? undefined,
                 });
                 // The descriptor helpers of a class that extends Array, reached
                 // from its constructor.
@@ -8914,11 +9546,13 @@ export class Lowerer {
                         order: unitOrder++,
                         roots: [],
                         lower: () => arrayClassFieldsFn(this, info),
+                        source: info.decl ?? undefined,
                     });
                     units.set(`%${cName}.species`, {
                         order: unitOrder++,
                         roots: [],
                         lower: () => arrayClassSpeciesFn(this, info),
+                        source: info.decl ?? undefined,
                     });
                 }
                 for (const { mName, member } of this.classMethodMembers(info)) {
@@ -8928,6 +9562,8 @@ export class Lowerer {
                         lower: () => info.localClass && !info.localClass.ready
                             ? null
                             : this.lowerClassMethodMember(info, member),
+                        source: member,
+                        owners: info.decl ? [info.decl] : [],
                     });
                 }
                 for (const prop of info.throwingSetters) {
@@ -8935,6 +9571,7 @@ export class Lowerer {
                         order: unitOrder++,
                         roots: [],
                         lower: () => this.throwingSetterFn(info, prop),
+                        source: info.decl ?? undefined,
                     });
                 }
             }
@@ -8944,6 +9581,8 @@ export class Lowerer {
                         order: unitOrder++,
                         roots: functionRoots(entry.member),
                         lower: () => lowerStaticMethod(this, info, name),
+                        source: entry.member,
+                        owners: info.decl ? [info.decl] : [],
                     });
                 }
             }
@@ -9218,11 +9857,16 @@ export class Lowerer {
         });
         // LIBRARY mode's extra reachability roots (LowerOptions.libRoots): the
         // profile-mapped exports are called from outside the graph, so they
-        // seed the worklist beside the init bodies. Unknown names are inert
-        // (the export-map resolution reports them as SC4002 later).
+        // seed the worklist beside the init bodies. Each name resolves through
+        // the entry module's export table to the unit that supplies it, so a
+        // re-exported function seeds its own module's unit. Unknown names are
+        // inert (the export-map resolution reports them as SC4002 later).
         const rootEdge = this.onEdge;
-        for (const root of extraRoots ?? [])
-            rootEdge?.(root);
+        for (const root of extraRoots ?? []) {
+            const unit = this.libExportUnit(root);
+            if (unit !== null)
+                rootEdge?.(unit);
+        }
         const shuffle = lowerShuffle();
         const lowerUnitBody = (name) => {
             const unit = units.get(name);
@@ -9230,17 +9874,77 @@ export class Lowerer {
             const owner = demandOwner(priority);
             return this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => this.withClosureRoot(name, unit.lower)));
         };
-        const recorded = journalMode() === "serial" ? waveStats() : null;
-        const host = recorded === null ? null : this.waveHost(loweredUnits, lowerUnitBody);
+        // With a unit store, every unit is recorded as in the serial mode, and
+        // a unit applies the record an earlier build stored for it where that
+        // record still holds (unit-reuse.ts).
+        const reuse = unitStore === null
+            ? null
+            : UnitReuse.open(unitStore, this.program, parts.map((fp) => fp.sf), {
+                facts: (declaration) => this.declarationFacts(declaration),
+                exportsOf: (specifier) => {
+                    const symbol = this.checker.getSymbolAtLocation(specifier);
+                    if (!symbol)
+                        return null;
+                    return this.checker
+                        .getExportsOfModule(symbol)
+                        .map((exported) => ts.symbolName(exported))
+                        .sort()
+                        .join("\n");
+                },
+                isLocal: (identifier, container) => {
+                    const declarations = this.checker.getSymbolAtLocation(identifier)?.declarations;
+                    if (declarations === undefined || declarations.length === 0)
+                        return false;
+                    const sf = ts.getSourceFileOfNode(container);
+                    return declarations.every((declaration) => ts.getSourceFileOfNode(declaration) === sf &&
+                        declaration.pos >= container.pos &&
+                        declaration.end <= container.end);
+                },
+            });
+        const recorded = journalMode() === "serial" || (reuse !== null && reuse.records) ? waveStats() : null;
+        const host = recorded === null
+            ? null
+            : this.waveHost(loweredUnits, lowerUnitBody, (name) => {
+                const priority = metadataPriority.get(name);
+                return { owner: demandOwner(priority), priority };
+            });
         const dump = recorded === null ? null : journalDump();
+        const fileOfUnit = (name) => {
+            const source = units.get(name)?.source;
+            return source === undefined ? null : ts.getSourceFileOfNode(source).fileName;
+        };
+        const waveReuse = reuse === null || !reuse.records
+            ? null
+            : {
+                verify: unitReuseVerify(),
+                stored: (name) => {
+                    // A unit without a declared rank takes the next expression
+                    // rank when it lowers, which applying a record would not
+                    // advance.
+                    const unit = units.get(name);
+                    const file = fileOfUnit(name);
+                    if (unit === undefined || file === null || !metadataPriority.has(name))
+                        return null;
+                    return reuse.candidate(name, file, unit.source ?? null, unit.owners ?? []);
+                },
+                check: (name, stored, pending, unit) => verifyStoredUnit(name, stored, pending, unit.record, unit.reasons),
+                note: (name, record, applied, files) => {
+                    const file = fileOfUnit(name);
+                    if (file !== null)
+                        reuse.note(name, file, record, applied, files);
+                },
+            };
         const recordLines = [];
         const drainUnits = () => {
+            // The waves of one drain have only checker prefetches between them, so
+            // they share the content their units start from (HeldTables).
+            const held = host !== null && recorded !== null ? new HeldTables(host.tables, recorded) : null;
             while (queue.length > 0) {
                 const wave = queue.splice(0);
                 shuffle?.(wave);
                 this.checker.prefetchRoots(wave.flatMap((name) => units.get(name).roots));
                 if (host !== null && recorded !== null) {
-                    lowerWaveRecorded(host, wave, recorded, dump === null ? null : recordLines);
+                    lowerWaveRecorded(host, wave, recorded, dump === null ? null : recordLines, waveReuse, held);
                     continue;
                 }
                 for (const name of wave) {
@@ -9260,6 +9964,7 @@ export class Lowerer {
                     }
                 }
             }
+            held?.check();
         };
         drainUnits();
         this.restoreGenericInstanceOrder();
@@ -9301,6 +10006,11 @@ export class Lowerer {
         classDispatch.finalize(this);
         if (dump !== null)
             writeRecords(dump, recordLines);
+        if (reuse !== null) {
+            reuse.finish();
+            if (process.env["SCRIPTC_TIMING"] === "1")
+                process.stderr.write(`scriptc lowering ${JSON.stringify({ phase: "unit-reuse", ...reuse.stats })}\n`);
+        }
         if (recorded !== null && process.env["SCRIPTC_TIMING"] === "1")
             process.stderr.write(`scriptc lowering ${JSON.stringify({ phase: "unit-records", ...recorded })}\n`);
         const orderedUnits = unitsInOrder();
@@ -9308,13 +10018,30 @@ export class Lowerer {
         this.shapes.settleDeclaredOrderPriorities();
         for (const finalize of this.shapeOrderMetadataFinalizers)
             finalize();
-        applyKeyOrderWitnesses(this, [
+        const keyOrderFunctions = [
             ...orderedUnits,
             ...initFunctions,
             ...instanceFunctions,
             ...this.liftedFns,
             ...this.implicitFns,
-        ]);
+        ];
+        // A program whose functions never convert a checked-dynamic value into a
+        // closed record cannot keep a source view anywhere, so the captures that
+        // consult one keep their static copy (record-sources.ts). Decided before
+        // the key-order pass, which reads the fact (a same-shape copy of a kept
+        // record keeps its keys; the `"k" in r` sites answer through the view).
+        const sourceScan = { memo: new Map(), visiting: new Set() };
+        for (const fn of keyOrderFunctions) {
+            if (!functionKeepsRecordSources(this, fn, sourceScan))
+                continue;
+            this.recordSourcesPossible = true;
+            break;
+        }
+        applyKeyOrderWitnesses(this, keyOrderFunctions);
+        // A kept width spread builds a record that holds undeclared keys, so the
+        // captures that consult a kept source must be active for it too.
+        if (this.keyOrder.keptWidthSpreads > 0)
+            this.recordSourcesPossible = true;
         observeRecordLiteralRebuilds(null);
         for (const finalize of this.shapeOrderHelperFinalizers)
             finalize();
@@ -9335,7 +10062,8 @@ export class Lowerer {
             ...byName(this.liftedFns),
             ...byName(this.implicitFns),
         ];
-        functions.push(...runtimeClassConstructs(this, functions));
+        for (const fn of runtimeClassConstructs(this, functions))
+            functions.push(fn);
         if (this.regexGroupResults)
             for (const fn of functions)
                 foldRegexSpanReads(this, fn);
@@ -9348,11 +10076,52 @@ export class Lowerer {
             files: parts.map((fp) => fp.sf),
         });
         this.reachableForArtifacts = reachable;
-        return { reachable, result: this.finishModule(functions) };
+        return { reachable, result: this.finishModule(functions, extraRoots !== undefined) };
+    }
+    /** What the steps before the worklist settled for a top-level
+     * declaration, as text without source positions (unit-reuse.ts): a
+     * function's signature, a class's layout and the signatures of its
+     * methods and statics, and the globals of a variable statement. */
+    declarationFacts(declaration) {
+        const positionFree = (key, value) => key === "loc" || key === "scope" ? undefined : value;
+        if (ts.isFunctionDeclaration(declaration)) {
+            const symbol = declSymbolOf(this, declaration);
+            const sig = symbol ? this.fnSigsBySymbol.get(symbol) : undefined;
+            return sig === undefined ? "" : JSON.stringify(sig, positionFree);
+        }
+        if (ts.isClassDeclaration(declaration)) {
+            const info = this.classes.get(this.classNamer(declaration));
+            if (info === undefined)
+                return "";
+            const staticMethods = [];
+            if (info.staticMethods)
+                for (const [name, method] of info.staticMethods)
+                    staticMethods.push({ name, params: method.params, ret: method.ret });
+            return JSON.stringify({
+                def: info.def,
+                fields: [...info.fields],
+                methods: [...info.methods],
+                statics: info.staticFields.map((field) => ({
+                    name: field.name,
+                    type: field.type,
+                    runtimeOptional: field.runtimeOptional ?? false,
+                    globalId: field.globalId,
+                    readonly: field.readonly,
+                })),
+                staticMethods,
+            }, positionFree);
+        }
+        if (ts.isVariableStatement(declaration)) {
+            const globals = [];
+            for (const decl of declaration.declarationList.declarations.nodes)
+                globals.push(this.globalsByDeclNode.get(decl) ?? null);
+            return JSON.stringify(globals, positionFree);
+        }
+        return "";
     }
     /** The lowerer's side of a recorded wave (unit-journal.ts).
      * `lowerUnitBody` lowers a unit as reachable emit does. */
-    waveHost(loweredUnits, lowerUnitBody) {
+    waveHost(loweredUnits, lowerUnitBody, ownerOf) {
         const scalars = this.journalScalars();
         const flags = new Map(scalars.map((scalar) => [scalar.name, scalar]));
         let instances = new Map();
@@ -9384,6 +10153,35 @@ export class Lowerer {
                 return undefined;
             }
         };
+        // Makes a recorded call again (resolves has answered true for it).
+        const replay = (event) => {
+            switch (event.kind) {
+                case "edge":
+                    this.noteEdge(event.name);
+                    break;
+                case "superConstructorEdge":
+                    this.noteSuperConstructorEdge(event.name);
+                    break;
+                case "virtualEdge":
+                    this.noteVirtualEdge(classNamed(event.name), event.detail);
+                    break;
+                case "functionDemand":
+                    this.noteGenericInstanceDemand(instanceNamed(event.name));
+                    break;
+                case "classDemand":
+                    this.noteGenericClassInstanceDemand(classNamed(event.name));
+                    break;
+                case "statement":
+                    this.countStatement(statementNode(event), event.detail ?? undefined);
+                    break;
+                case "failedStatement":
+                    this.countStatementFailed(statementNode(event), event.detail ?? undefined);
+                    break;
+                case "flag":
+                    flags.get(event.name).set();
+                    break;
+            }
+        };
         return {
             tables: this.journalTables(),
             scalars,
@@ -9428,6 +10226,15 @@ export class Lowerer {
                         return true;
                 }
             },
+            keep: (name, fn, events) => {
+                if (fn)
+                    loweredUnits.set(name, fn);
+                const { owner, priority } = ownerOf(name);
+                this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => {
+                    for (const event of events)
+                        replay(event);
+                }));
+            },
         };
     }
     /** Reachability hook (see emitReachable): fires when lowering resolves a
@@ -9512,10 +10319,12 @@ export class Lowerer {
         }
         const captured = this.diags.splice(diagsBefore);
         if (captured.some((d) => d.code === "SC9001")) {
-            this.diags.push(...captured);
+            for (const d of captured)
+                this.diags.push(d);
             return null;
         }
-        this.runtimeFences.push(...captured);
+        for (const d of captured)
+            this.runtimeFences.push(d);
         const fence = this.runtimeFenceStmt(captured[0], node, target.fallback, target.bareMessage);
         const loc = locOf(node);
         if (target.kind === "statement")
@@ -9785,7 +10594,8 @@ export class Lowerer {
             .slice(diagsBefore)
             .filter((d) => d.rejects !== undefined || this.loweredOnceDiags.has(d));
         this.diags.length = diagsBefore;
-        this.diags.push(...kept);
+        for (const d of kept)
+            this.diags.push(d);
     }
     /** A unit that still fails after its retries commits its first
      * attempt's own diagnostics (`first`, taken before the first
@@ -9796,7 +10606,11 @@ export class Lowerer {
         const carried = (d) => d.rejects !== undefined || this.loweredOnceDiags.has(d);
         const kept = this.diags.slice(diagsBefore).filter(carried);
         this.diags.length = diagsBefore;
-        this.diags.push(...first.filter((d) => !carried(d)), ...kept);
+        for (const d of first)
+            if (!carried(d))
+                this.diags.push(d);
+        for (const d of kept)
+            this.diags.push(d);
     }
     /** Lowers one unit whose body-level poison skips it (a generic
      * instance), with localized failure's commit point: a degradable type
@@ -10025,7 +10839,14 @@ export class Lowerer {
             }
             this.typeFail(node, type, "index-signature", indexSignatureTypeDiag(this.checker.typeToString(type), locOf(node)));
         }
-        // Attribute an unsupported package type to its package.
+        // Attribute an unsupported package type to its package. A PACKAGE DATA
+        // SHAPE (an interface or type alias declared only by a package the
+        // module graph never loads) never reaches this: it describes data the
+        // program itself builds, so mapTypeEntry already widened it to the
+        // checked-dynamic value exactly as it does for the same shape declared
+        // locally. What arrives here is a package's VALUE shape — a class or a
+        // merged value declaration, which only that package's implementation
+        // could produce.
         {
             const pkg = this.npmPackageOf(widened);
             if (pkg) {
@@ -10083,9 +10904,11 @@ export class Lowerer {
         // story, naming the type — and for the families with a WHY, the same
         // pointed reason the identifier/constructor chokepoints teach.
         if (stdlibNominal) {
-            const intlHint = "Intl formatter values have no representation — the COMPOSED en-US forms lower: " +
-                'new Intl.NumberFormat("en-US").format(x) and x.toLocaleString("en-US") with default options; ' +
-                "the rest is ICU locale data the binary does not carry";
+            const intlHint = "Intl formatter values have no representation — the COMPOSED forms lower: " +
+                'new Intl.NumberFormat("en-US").format(x), x.toLocaleString("en-US") and ' +
+                "x.toLocaleString() with default options, d.toLocaleString(), d.toLocaleTimeString(), " +
+                "and Intl.Segmenter with grapheme or word granularity; the formatter objects " +
+                "themselves (locale negotiation, resolvedOptions, options bags) remain unsupported";
             const typeHints = {
                 ArrayBuffer: "fixed ArrayBuffer storage and typed-array views are supported; resizable and detached storage are not modeled",
                 SharedArrayBuffer: "fixed SharedArrayBuffer storage is supported; growable shared storage is not modeled",
@@ -10124,6 +10947,13 @@ export class Lowerer {
         this.pushDiag(diag);
         throw new PoisonError();
     }
+    /** A read of a Node 24 global the native runtime does not implement
+     * (host-globals.ts): refusing is the honest answer, and the reason id
+     * lets a Node island run the module instead. */
+    hostGlobalFence(name, node) {
+        this.pushDiag(hostGlobalDiag(name, locOf(node)));
+        throw new PoisonError();
+    }
     /** The declaration-side refusal of a stdlib-global snapshot read as a
      * VALUE (stdlibGlobalAliasDecl): report once, at the declaration's name,
      * naming the type the program asked the compiler to hold when it has a
@@ -10474,7 +11304,12 @@ export class Lowerer {
      * (`T`, `T[]`, `{ v: T }`, `(x: T) => T` all resolve). Inert outside
      * generic instantiation. */
     typeParamResolver = (t) => {
-        if (!this.typeParamBindings || !(t.flags & ts.TypeFlags.TypeParameter))
+        if (!(t.flags & ts.TypeFlags.TypeParameter))
+            return null;
+        // The answer is the current bindings' (an unbound parameter maps by the
+        // symbolic rules), so the mapping may not leave its scope.
+        noteScopeSensitiveMapping();
+        if (!this.typeParamBindings)
             return null;
         const sym = t.getSymbol();
         return (sym && this.typeParamBindings.get(sym)) ?? null;
@@ -10486,7 +11321,10 @@ export class Lowerer {
      * over literal arguments). Inert outside generic function and class
      * instantiation. */
     typeParamTsResolver = (t) => {
-        if (!this.typeParamTsBindings || !(t.flags & ts.TypeFlags.TypeParameter))
+        if (!(t.flags & ts.TypeFlags.TypeParameter))
+            return null;
+        noteScopeSensitiveMapping();
+        if (!this.typeParamTsBindings)
             return null;
         const sym = t.getSymbol();
         return (sym && this.typeParamTsBindings.get(sym)) ?? null;
@@ -10496,7 +11334,13 @@ export class Lowerer {
      * (boundAliasInstances), or null when its signature never instantiated
      * that reference. Inert outside generic function instantiation. */
     boundAliasTsResolver = (t) => {
-        if (!this.typeParamTsBindings || t.getAliasTypeArguments().length === 0)
+        const aliasArguments = t.getAliasTypeArguments().length;
+        if (aliasArguments === 0)
+            return null;
+        // boundAliasInstances is keyed by the installed ts bindings, so this
+        // answer belongs to the instantiation that asks.
+        noteScopeSensitiveMapping();
+        if (!this.typeParamTsBindings)
             return null;
         const tsBindings = this.typeParamTsBindings;
         return (this.boundAliasInstances.get(t)?.find((entry) => entry.tsBindings === tsBindings)?.instance ??
@@ -10570,8 +11414,26 @@ export class Lowerer {
                 return dyn;
             this.badType(node, t);
         }
+        // A JavaScript binding whose inferred type holds a union of functions
+        // and arrays (a test table of `[fn, cases]` rows, or one row
+        // destructured): the checked-dynamic kind dynFallbackType gives the
+        // unmappable spellings of such tables, so the rows keep their functions'
+        // names and the destructured items their values.
+        if (isJsSourceFile(ts.getSourceFileOfNode(node)) && this.mixesFunctionsWithArrays(mapped))
+            return DYN;
         return jsOpenObjectType(node, mapped, this.shapes, this.unions);
     }
+    /** Whether `type`, or an array element type inside it, is a union with
+     * both a function arm and an array arm. */
+    mixesFunctionsWithArrays(type) {
+        if (type.kind === "array")
+            return this.mixesFunctionsWithArrays(type.elem);
+        if (type.kind !== "union")
+            return false;
+        const arms = this.unions.get(type.unionId)?.arms ?? [];
+        return ((arms.some((arm) => arm.kind === "func") && arms.some((arm) => arm.kind === "array")) ||
+            arms.some((arm) => arm.kind === "array" && this.mixesFunctionsWithArrays(arm)));
+    }
     /** Exact-shape enforcement (SC2002). Records are monomorphic structs, so
      * everywhere a value flows into a typed slot (call arg, initializer,
      * assignment, field, return) the shapes must MATCH — or width-coerce:
@@ -10929,6 +11791,28 @@ export class Lowerer {
                 if (boxed)
                     return boxed;
             }
+            // A node:path family is its module object (pathModuleValue), the
+            // bare module the target platform's family.
+            if (expr.type.kind === "moduleNs" &&
+                (expr.type.moduleId === "builtin:path" ||
+                    expr.type.moduleId === "builtin:path/posix" ||
+                    expr.type.moduleId === "builtin:path/win32")) {
+                const family = expr.type.moduleId !== "builtin:path"
+                    ? expr.type.moduleId.slice("builtin:".length)
+                    : builtinModuleConstOf(this, "path", "sep") === "\\"
+                        ? "path/win32"
+                        : "path/posix";
+                const value = pathModuleValue(this, family, 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 === "moduleNs" &&
                 expr.type.moduleId === "builtin:events" &&
                 isJsSourceFileName(expr.loc.file)) {
@@ -10967,7 +11851,7 @@ export class Lowerer {
                         (this.unions.get(expr.type.unionId)?.arms.some(liveReference) ?? false));
                 return {
                     kind: "dynFrom",
-                    value: expr,
+                    value: this.checkedBuiltinValue(expr),
                     type: DYN,
                     loc: expr.loc,
                     ...(liveRef ? { liveRef: true } : {}),
@@ -11249,6 +12133,14 @@ export class Lowerer {
             if (helper) {
                 return { kind: "call", callee: helper, args: [expr], type: expected, loc: expr.loc };
             }
+            // Inside a type assertion's operand the program claimed the value's
+            // shape: an arm the asserted target excludes traps (divergence 38's
+            // lying-assertion stance) instead of refusing the whole conversion.
+            if (this.coercions.assertedOperand > 0) {
+                const checked = this.widthLiftPlan(expr.type, expected);
+                if (checked?.how === "checkedRetag")
+                    return this.applyWidthLift(checked, expr, expected, expr.loc);
+            }
             return assertedConversion(this, expr, expected) ?? expr;
         }
         if (expr.type.kind === "void") {
@@ -11501,8 +12393,8 @@ export class Lowerer {
     recordUnionRouteHelper(source, toId, loc) {
         return recordUnionRouteHelper(this, source, toId, loc);
     }
-    unionRetagHelper(fromId, toId, loc, trappable) {
-        return unionRetagHelper(this, fromId, toId, loc, trappable);
+    unionRetagHelper(fromId, toId, loc, trappable, classRoutes) {
+        return unionRetagHelper(this, fromId, toId, loc, trappable, classRoutes);
     }
     narrowedArmHelper(fromId, target, loc, message) {
         return narrowedArmHelper(this, fromId, target, loc, message);
@@ -12040,6 +12932,11 @@ export class Lowerer {
                             elements.every((element) => element !== null && this.widthLiftPlan(element.type, candidate.elem) !== null));
                     }
                 }
+                // An EMPTY literal carries no element to select an arm by: it
+                // builds as the union's first array arm (the emptyArrayLiteralArm
+                // rule the contextual union and the `?? []` default share).
+                if (!arm)
+                    arm = emptyArrayLiteralArm(x, arms) ?? undefined;
                 if (arm) {
                     const built = this.lowerArrayLiteral(x, arm);
                     return this.coerceInto(node, built, expected);
@@ -12137,6 +13034,12 @@ export class Lowerer {
             return true;
         if (to.inner.kind === "void")
             return from.inner.kind !== "void";
+        // A module namespace widens into a checked-dynamic payload: both settle
+        // the module's namespace object (coerceToExpected routes the value
+        // through moduleNamespacePromiseDynValue). The joint payload of several
+        // namespace-valued promise arms is exactly this dyn (mergePromiseArms).
+        if (from.inner.kind === "moduleNs" && to.inner.kind === "dyn")
+            return true;
         return (this.dynConvertible(from) &&
             canDynCheckTo(to, (id) => this.shapes.get(id), (id) => this.unions.get(id)));
     }
@@ -12178,8 +13081,81 @@ export class Lowerer {
             return this.lowerExprExpecting(node, expected);
         if (this.returnsFreshCollection(node) && expected.kind !== "void")
             return this.lowerExprExpecting(node, expected);
+        // A fresh object literal into a record result: the same
+        // destination-directed construction. An unannotated method inside a
+        // contextually typed literal is checked against the CONTEXTUAL
+        // signature's result while its own return type stays the literal's
+        // inferred (narrower) record — `ToolDefinition<Schema, Details>`
+        // methods returning `{ content, details }`. Building at the
+        // contextual type would then coerce that wider record into the
+        // declared result and refuse; the result slot is the layout.
+        if (this.returnsFreshRecord(node, expected))
+            return this.lowerExprExpecting(node, expected);
         return this.asyncReturnValueOf(node, this.lowerExpr(node), expected);
     }
+    /** A fresh object literal returned into a RECORD result whose ordinary
+     * construction cannot reach that result: not a thenable, so it is built
+     * at the result type like a synchronous return. An unannotated method
+     * inside a contextually typed literal is checked against the CONTEXTUAL
+     * signature's result while its own return type stays the literal's
+     * inferred (narrower) record — `ToolDefinition<Schema, Details>` methods
+     * returning `{ content, details }`. Building at the contextual type
+     * would then coerce that wider record into the declared result and
+     * refuse; the result slot is the layout. A literal that declares `then`
+     * is awaited instead, and a literal whose contextual build does convert
+     * keeps the ordinary lowering, so no convertible value changes. */
+    returnsFreshRecord(node, expected) {
+        if (expected.kind !== "record")
+            return false;
+        let e = node;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        // A conditional of fresh object literals (`return valid ? { entries, … }
+        // : { entries: [], … }`) is the same fresh construction per arm: the
+        // checker's join can carry an EMPTY arm's uninhabited element
+        // representation, which the populated arm then cannot lift into. Build
+        // both arms at the declared result, exactly as a synchronous return
+        // does. Neither arm can be a thenable (an object literal that declares
+        // `then` is awaited instead), so no promise adoption is bypassed. A
+        // conditional whose join every arm already lifts into takes the same
+        // path for the same layout: each arm is constructed at the result
+        // instead of the join being constructed and width-copied into it (the
+        // zero-cost gate lists the programs whose code that changes).
+        if (ts.isConditionalExpression(e))
+            return this.isFreshRecordLiteral(e.whenTrue) && this.isFreshRecordLiteral(e.whenFalse);
+        return this.freshRecordLiteralInto(e, expected);
+    }
+    /** A parenthesized fresh object literal that does not declare `then`. */
+    isFreshRecordLiteral(node) {
+        let e = node;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        return (ts.isObjectLiteralExpression(e) &&
+            this.checker.getPropertyOfType(this.typeOf(e), "then") === undefined);
+    }
+    /** One arm of a returned conditional: a fresh object literal whose
+     * ordinary construction cannot reach the declared result (see
+     * returnsFreshRecord). */
+    freshRecordLiteralInto(node, expected) {
+        let e = node;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (!ts.isObjectLiteralExpression(e))
+            return false;
+        if (this.checker.getPropertyOfType(this.typeOf(e), "then") !== undefined)
+            return false;
+        // The record the ordinary path builds: the literal's context, with an
+        // async return's `T | PromiseLike<T>` stripped to the awaited record
+        // (object-literals.ts does the same before mapping).
+        let context = this.checker.getContextualType(e) ?? this.typeOf(e);
+        if (context.isUnionType() &&
+            ts.constituentTypes(context).some((t) => ts.symbolNameOf(t.getSymbol()) === "PromiseLike"))
+            context = this.checker.getAwaitedType(context) ?? context;
+        const built = this.mapTypeOf(context);
+        if (!built || built.kind !== "record")
+            return false;
+        return this.widthLiftPlan(built, expected) === null;
+    }
     /** An array literal or a `new Map(...)`, `new Set(...)` or `new
      * Array(...)` of the builtins: a fresh collection, never a thenable, so
      * an async return takes the declared result type as its construction
@@ -12207,6 +13183,20 @@ export class Lowerer {
             isJsSourceFile(ts.getSourceFileOfNode(node)) &&
             ts.isObjectLiteralExpression(literal));
     }
+    /** Whether `node`'s TS type is a `Promise<never>` (the throw-only async
+     * function's declared result): the promise can never settle, so the value
+     * it would resolve to is unreachable. The IR keeps `Promise<never>` as a
+     * promise with a void payload, exactly like `Promise<void>`, so the TS
+     * payload type is what separates the two. */
+    promisePayloadIsNever(node) {
+        const t = this.typeOf(node);
+        if ((t.flags & ts.TypeFlags.Object) === 0)
+            return false;
+        if ((t.objectFlags & ts.ObjectFlags.Reference) === 0)
+            return false;
+        const args = this.checker.getTypeArguments(t);
+        return args.length === 1 && (args[0].flags & ts.TypeFlags.Never) !== 0;
+    }
     /** 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. */
@@ -12215,6 +13205,13 @@ export class Lowerer {
             return null;
         if (this.ctx.isAsync && e.type.kind === "promise" && expected.kind !== "promise") {
             const awaited = this.returnedPromiseAwait(e);
+            // A `Promise<never>` never settles, so the awaited value is
+            // unreachable: it fills any result shape instead of failing the
+            // void-to-record conversion.
+            if (expected.kind !== "void" &&
+                e.type.inner.kind === "void" &&
+                this.promisePayloadIsNever(node))
+                return this.divergentValue(awaited, expected);
             return this.coerceInto(node, awaited, expected);
         }
         return this.coerceInto(node, e, expected);
@@ -12324,7 +13321,8 @@ export class Lowerer {
         }
         if (this.adoptsReturnedPromise() &&
             !this.returnsLiteralIntoDyn(node, expected) &&
-            !this.returnsFreshCollection(node)) {
+            !this.returnsFreshCollection(node) &&
+            !this.returnsFreshRecord(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.
@@ -12436,6 +13434,10 @@ export class Lowerer {
      * undefined-armed union fields, which can be absent, and `true` for
      * every other declared field. */
     recordFieldPresent(obj, shapeId, field, loc) {
+        // A partial record view (partial-assertions.ts) can lack a field its
+        // asserted literal never wrote, whatever the field's required type.
+        if (partialAssertionFields(this, shapeId).has(field))
+            return { kind: "recordHas", obj, shapeId, field, type: BOOL, loc };
         const f = this.shapes.get(shapeId)?.fields.find((x) => x.name === field);
         if (f && f.type.kind === "union" && this.armTag(f.type.unionId, UNDEFINED_T) >= 0) {
             return { kind: "recordHas", obj, shapeId, field, type: BOOL, loc };
@@ -13139,7 +14141,7 @@ export class Lowerer {
      * call runs for its effects (it throws or exits), and the expression ends
      * in an unreachable trap instead of producing a value. The result reads an
      * uninitialized hidden local that control never reaches. */
-    divergentValue(call, expected) {
+    divergentValue(call, expected, message = "unreachable: a 'never' call returned — please report this") {
         const loc = call.loc;
         const slot = this.declareHiddenLocal("%never", expected);
         slot.mutable = true;
@@ -13151,7 +14153,7 @@ export class Lowerer {
                 {
                     kind: "runtimeFence",
                     code: "SC9002",
-                    message: "unreachable: a 'never' call returned — please report this",
+                    message,
                     loc,
                 },
             ],
@@ -13739,6 +14741,14 @@ export class Lowerer {
         this.rejectUnresolvedSymbol(this.resolveValueSymbol(ident), ident.text, ident, fallback);
     }
     rejectUnresolvedSymbol(symbol, name, node, fallback) {
+        // A `.js` WRITE to a name nothing declares. Sloppy mode resolves it by
+        // creating a property on the global object — process-wide state a native
+        // binary has no object for, so those programs run in a Node island
+        // (plan D-5). Until the write is routed there it is refused by name
+        // rather than by the generic no-lowering text.
+        if (symbol === null && isJsWriteTarget7(node) && isJsSourceFile(ts.getSourceFileOfNode(node))) {
+            this.unsupported("SC1091", node, `writing the undeclared name '${name}' in a JavaScript source`, undefined, isStrictCode(node) ? undefined : "implicit-global-write");
+        }
         if (this.isBlockedBinding(symbol)) {
             this.pushDiag(blockedBindingUseDiag(name, locOf(node)));
             throw new PoisonError();
@@ -13929,11 +14939,58 @@ export class Lowerer {
      * members by name + this provenance, and everything else those files
      * declare hits the SC2020-family fence). The file half of every
      * supported-surface provenance check. */
-    isStdlibFile = (sf) => sf.fileName === this.ambient ||
-        sf.fileName === this.overridesAmbient ||
-        isFallbackDtsPath(sf.fileName) ||
-        this.program.isSourceFileDefaultLibrary(sf) ||
-        (sf.isDeclarationFile && isNodeTypesPath(sf.fileName));
+    isStdlibFile = (sf) => this.facts.isStdlibFile(sf);
+    /** provenanceOf's answers (type-mapper.ts's SymbolProvenance), keyed by
+     * symbol. A symbol's declarations are fixed for one loaded program, and
+     * the mapper asks on every object type it maps, so the round shares one
+     * map (lowering-facts.ts). */
+    get symbolProvenance() {
+        return this.facts.symbolProvenance;
+    }
+    /** SCRIPTC_LOWERING_FACTS_VERIFY: the shared provenance memo answered, so
+     * recompute it and fail on a disagreement (lowering-facts.ts). */
+    verifySymbolProvenanceAnswer(sym, answer) {
+        const fresh = computeSymbolProvenance(sym, this.isStdlibFile);
+        // The two lazily filled answers (`??=` on a hit) are declaration-only
+        // too, so recompute the ones an answer carries. The pass that filled one
+        // stored the value it computed, and this comparison catches a later pass
+        // that would have filled a different one.
+        const freshWebAssembly = answer.webAssembly === undefined
+            ? undefined
+            : declaresWebAssemblyNamespace(sym.declarations, this.isStdlibFile);
+        const freshLegacyUrl = answer.legacyUrl === undefined
+            ? undefined
+            : declaresLegacyUrl(sym.declarations, { isStdlibFile: this.isStdlibFile });
+        const same = fresh.stdlibInterface === answer.stdlibInterface &&
+            fresh.stdlibClass === answer.stdlibClass &&
+            fresh.libInterface === answer.libInterface &&
+            freshWebAssembly === answer.webAssembly &&
+            freshLegacyUrl === answer.legacyUrl;
+        this.facts.noteVerified("symbolProvenance");
+        if (same)
+            return;
+        if (freshWebAssembly !== undefined)
+            fresh.webAssembly = freshWebAssembly;
+        if (freshLegacyUrl !== undefined)
+            fresh.legacyUrl = freshLegacyUrl;
+        throw new InternalCompilerError(`shared symbol provenance for ${ts.symbolName(sym)} does not match a fresh ` +
+            `computation: shared ${JSON.stringify(answer)}, recomputed ${JSON.stringify(fresh)}`);
+    }
+    /** Whether the file holds declarations of an explicitly mapped external
+     * type surface (coverage's --external-types) or of the declaration-typed
+     * boundary's generated types. Both are fixed for the program, and the
+     * mapper asks per type (lowering-facts.ts keeps the answer). */
+    isExternalTypeFile = (sf) => this.facts.isExternalTypeFile(sf, this.externalTypeSpecifiersByFile);
+    /** tsgoPath(resolve(sf.fileName)): the path spelling the module tables
+     * key by. A source file's path cannot change while the program lowers. */
+    pathOf = (sf) => this.facts.pathOf(sf);
+    /** Whether values of `type` are island handles (boundary.ts's
+     * isForeignType; the answers and their invalidation live in
+     * lowering-facts.ts). The type mapper asks this on every mapType call,
+     * memo hits included. */
+    foreignType(type) {
+        return this.facts.foreignType(type, this.nodeIslands, this.checker);
+    }
     nodeTypesOnlySymbol(sym) {
         return nodeTypesOnlySymbol(this, sym);
     }
@@ -14355,6 +15412,7 @@ export class Lowerer {
             : null;
     }
     fieldSetStmt(target, value, loc, blame) {
+        refuseHeldEnvWrite(this, blame);
         return markSloppyRecordWrites(this, fieldSetStmt(this, target, value, loc, blame), blame);
     }
     lowerFieldCompound(access, op, rhsNode, loc) {
@@ -14851,6 +15909,8 @@ export class Lowerer {
         const valueParams = fn.valueParams;
         if (!valueParams)
             return null;
+        if (fn.checked?.only)
+            return checkedNativeCallableValue(this, fn, display, loc);
         const shapes = valueParams.map((param) => {
             if (param.mode === "rest")
                 return { mode: "rest", type: arrayOf(param.type) };
@@ -14871,6 +15931,8 @@ export class Lowerer {
             fnName = keyedHelperName(this, `%builtin.value.${fn.valueFn ?? fn.fn}`, key);
             this.builtinCallableValueFns.set(key, fnName);
             this.builtinCallableValueNames.set(fnName, fn.valueName ?? display.slice(display.lastIndexOf(".") + 1));
+            if (fn.valueNameMainThreadOnly)
+                this.builtinCallableValueMainThreadNames.add(fnName);
             if (fn.valueLength !== undefined)
                 this.builtinCallableValueLengths.set(fnName, fn.valueLength);
             const params = funcType.params.map((type, index) => ({
@@ -14951,19 +16013,42 @@ export class Lowerer {
                 loc,
             });
         }
+        if (valueParams.some((param) => param.name !== undefined)) {
+            // Every materialization writes this entry at ITS location, so a second
+            // one overwrites the first in place. A table only grows by addition, so
+            // that change is no part of this unit's function: name it (unit-journal.ts
+            // UnitEvents.touch), and the change is counted here instead of being
+            // found by HeldTables.check as an unnamed write.
+            if (this.builtinCheckedValues.has(fnName))
+                this.unitEvents?.touch(fnName);
+            this.builtinCheckedValues.set(fnName, { fn, display, loc });
+        }
         return { kind: "closure", fnName, captures: [], type: funcType, loc };
     }
+    /** A builtin function value about to become untyped: its checked twin
+     * when the builtin names its parameters (checkedNativeCallableValue), so
+     * untyped callers meet Node's argument validation. Typed slots keep the
+     * typed adapter. */
+    checkedBuiltinValue(expr) {
+        const checked = expr.kind === "closure" ? this.builtinCheckedValues.get(expr.fnName) : undefined;
+        return checked
+            ? checkedNativeCallableValue(this, checked.fn, checked.display, checked.loc)
+            : expr;
+    }
     /** The name and length a builtin function's adapter boxes under: the ones
-     * Node's function carries (`[Function: randomUUID]`). Empty for any other
-     * value. */
+     * Node's function carries (`[Function: randomUUID]`), with the main-thread
+     * qualifier of a name a Worker does not carry (`process.cwd`). Empty for
+     * any other value. */
     builtinFunctionIdentity(expr) {
         if (expr.kind !== "closure")
             return {};
         const name = this.builtinCallableValueNames.get(expr.fnName);
         const length = this.builtinCallableValueLengths.get(expr.fnName);
+        const mainThreadOnly = this.builtinCallableValueMainThreadNames.has(expr.fnName);
         return {
             ...(name !== undefined ? { fnName: name } : {}),
             ...(length !== undefined ? { fnLength: length } : {}),
+            ...(mainThreadOnly ? { fnNameMainThreadOnly: true } : {}),
         };
     }
     isBuiltinCallableValue(expr) {
@@ -15378,6 +16463,16 @@ function droppedMembers(lowerer, from, to, seen) {
     }
     return out;
 }
+/** A JSDoc `@param` type on a set accessor's parameter is an annotation like
+ * a variable's `@type` (hasJsTypeAnnotation, lower-stmts.ts): the setter
+ * keeps its declared storage. Setters take exactly one parameter, so any
+ * `@param` before it belongs to it. */
+function hasJsSetterParamAnnotation(param) {
+    const accessor = param.parent;
+    if (!accessor)
+        return false;
+    return /@param\b/.test(ts.getSourceFileOfNode(accessor).text.slice(accessor.pos, ts.tokenStartOfNode(param)));
+}
 /** 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. */