@scriptc/compiler 0.4.7 → 0.4.8

package/dist/frontend/lowering/lowerer.js

@@ -6,19 +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, 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";
@@ -32,6 +32,7 @@ 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";
@@ -70,6 +71,7 @@ import { boxBuiltinValuesChecked, lowerUtilTypeValue, checkedNativeCallableValue
 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";
@@ -94,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";
@@ -104,6 +107,7 @@ 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";
@@ -132,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, isJsWriteTarget7, 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";
@@ -219,6 +223,8 @@ 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). */
@@ -470,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,
@@ -484,6 +499,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         externalTypes,
         externalTypeSpecifiersByFile,
         tierMode,
+        runtimeOptionalReport,
     });
     const ffiValidation = validateFfiImports(validation);
     timing("ffi-validate");
@@ -495,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,
@@ -508,6 +526,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ffiBindingSymbols: ffiValidation.symbolsByName,
         });
     for (const d of extraModuleCycleDiags)
@@ -527,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,
@@ -539,6 +560,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ffiBindingSymbols: ffiValidation.symbolsByName,
             wholeSlotDegradation: true,
         });
@@ -565,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,
@@ -578,6 +602,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ffiBindingSymbols: ffiValidation.symbolsByName,
             generalNodeStreams: true,
             ...(dyn ? { dynNodeStreams: true } : {}),
@@ -610,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 } : {}),
@@ -617,6 +643,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             reachable,
             targetPlatform,
             startupCrash,
+            admittedOpinions: options.admittedOpinions,
             inlineRequireCycleCalls,
             dynamicImportRejections: options.dynamicImportRejections,
             ffiImports,
@@ -627,6 +654,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
             externalTypes,
             externalTypeSpecifiersByFile,
             tierMode,
+            runtimeOptionalReport,
             ...(resultLowerer.wholeSlotDegradation ? { wholeSlotDegradation: true } : {}),
         });
         for (const d of extraModuleCycleDiags)
@@ -637,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 = [
@@ -747,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 } : {}),
@@ -756,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,
@@ -767,6 +811,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         externalTypes,
         externalTypeSpecifiersByFile,
         tierMode,
+        runtimeOptionalReport,
     });
     let remainder = remainderPass(generalNodeStreams);
     let rem = remainder.run();
@@ -793,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);
@@ -855,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)
@@ -1283,6 +1329,10 @@ function isAnonymousCallableDefinition(node) {
  * 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;
@@ -1297,6 +1347,23 @@ export function jsFuncNameOf(node, lowerer) {
             n = declaration;
             break;
         }
+        // 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;
         let value = declaration.initializer;
@@ -1344,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;
 }
@@ -1400,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;
@@ -1410,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();
@@ -1689,6 +1790,15 @@ export class Lowerer {
      * 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
@@ -1791,7 +1901,7 @@ export class Lowerer {
      * (programPatchesStdio in builtins/process.ts). */
     patchesStdio = null;
     /** The write-replacement site programPatchesStdio found: the executable
-     * planner refuses it beside Node islands (SC8020). */
+     * planner refuses it beside Node islands (SC8006). */
     stdioPatchSites = [];
     requestInitPropMutatedSyms = null;
     emitterEventTable = null;
@@ -1851,6 +1961,15 @@ 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. */
@@ -2585,6 +2704,10 @@ 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();
@@ -2813,6 +2936,25 @@ 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();
@@ -2879,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,
@@ -2907,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
@@ -3260,6 +3458,7 @@ 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),
@@ -3297,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),
@@ -3310,6 +3510,11 @@ export class Lowerer {
             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),
@@ -3405,6 +3610,13 @@ 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),
@@ -3501,10 +3713,9 @@ export class Lowerer {
         // settings
         "frontendServices",
         "nodeIslands",
-        "ambient",
-        "overridesAmbient",
         "remainder",
         "tierMode",
+        "runtimeOptionalReport",
         "generalNodeStreams",
         "dynNodeStreams",
         "targetPlatform",
@@ -3531,10 +3742,29 @@ export class Lowerer {
         "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",
@@ -3551,7 +3781,10 @@ export class Lowerer {
         "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",
@@ -3569,7 +3802,6 @@ export class Lowerer {
         "slotOriginMemo",
         "recordOriginMemo",
         "boundaryCastOrder",
-        "declBoundaryMemo",
         "structuredCloneReadCounts",
         // state of the unit being lowered
         "assertedValues",
@@ -3626,6 +3858,11 @@ export class Lowerer {
         "spreadArmOverrides",
         "splitIdentifierUses",
         "typeMemo",
+        "sharedTypeMemo",
+        "scopedTypeMemos",
+        "lastMemoOuter",
+        "lastMemoInner",
+        "lastMemo",
         "fnStack",
         "positions.nodesByKey",
         "positions.paths",
@@ -3654,6 +3891,7 @@ 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),
@@ -3711,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). */
@@ -3888,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
@@ -3944,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). */
@@ -3981,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;
@@ -3990,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 ?? [];
@@ -4002,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,
@@ -4044,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 }
@@ -4055,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.
@@ -4107,14 +4355,23 @@ export class Lowerer {
             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),
@@ -4149,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();
@@ -4157,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. */
@@ -4171,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
@@ -4269,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);
@@ -4415,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) {
@@ -4434,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
@@ -5551,12 +5859,32 @@ export class Lowerer {
      * 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. */
+     * 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))
@@ -5590,7 +5918,7 @@ export class Lowerer {
         }
     }
     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();
@@ -5903,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))
+            // 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 receiverType = this.typeOf(e.expression);
-            if (this.checker.getIndexInfosOfType(receiverType).length === 0)
-                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));
@@ -8477,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();
@@ -8687,12 +9032,18 @@ 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)
@@ -8707,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
@@ -8829,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] } : {}),
@@ -8857,7 +9213,7 @@ export class Lowerer {
         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 (SC8020): an
+        // 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)
@@ -8988,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
@@ -9031,21 +9423,42 @@ 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);
-            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);
+        // 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).
@@ -9444,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);
@@ -9658,7 +10076,7 @@ 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
@@ -10421,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) {
@@ -10522,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
@@ -10872,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;
@@ -10884,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;
@@ -10894,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 ??
@@ -11687,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") {
@@ -11939,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);
@@ -12580,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)));
     }
@@ -12648,6 +13108,36 @@ export class Lowerer {
         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))
@@ -13651,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;
@@ -13663,7 +14153,7 @@ export class Lowerer {
                 {
                     kind: "runtimeFence",
                     code: "SC9002",
-                    message: "unreachable: a 'never' call returned — please report this",
+                    message,
                     loc,
                 },
             ],
@@ -14257,7 +14747,7 @@ export class Lowerer {
         // (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`);
+            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)));
@@ -14449,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);
     }
@@ -15394,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) => ({
@@ -15475,6 +16014,13 @@ export class Lowerer {
             });
         }
         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 };
@@ -15490,16 +16036,19 @@ export class Lowerer {
             : 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) {
@@ -15914,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. */