@scriptc/compiler 0.4.6 → 0.4.7

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";
@@ -8,7 +9,8 @@ import { Normalizer } from "../canon.js";
 import { compactDeclOrigins, inPackageFile, recordOrigin, slotOrigin, } from "./decl-origin.js";
 import { isDeclBoundaryFile } from "../decl-projection.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";
@@ -30,11 +32,12 @@ 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 { 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,7 +66,7 @@ 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";
@@ -102,6 +105,7 @@ import { analyzeTiers, dynamicStatementCount, } from "../tier-analysis.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import { finalizeClassMethodValues } from "./class-method-values.js";
 import { finalizePrivateBrands } from "./private-brands.js";
+import { finalizeFunctionNames } from "./function-names.js";
 import { INSPECT_CUSTOM_MEMBER, tableKeyFieldType } from "./symbol-fields.js";
 export { newFnCtx } from "./function-context.js";
 /* AST + checker → IR.
@@ -131,7 +135,7 @@ 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 { 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 { 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 { builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
 import { builtinClassAliasOf, runtimeClassValueOfType, } from "./builtins/class-values.js";
@@ -146,7 +150,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 +173,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,6 +211,8 @@ 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";
@@ -508,7 +514,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         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;
@@ -1263,6 +1269,19 @@ 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) {
     let n = node;
     while (ts.isParenthesizedExpression(n))
@@ -1278,14 +1297,28 @@ export function jsFuncNameOf(node, lowerer) {
             n = declaration;
             break;
         }
-        if (!declaration ||
-            !ts.isVariableDeclaration(declaration) ||
-            !declaration.initializer ||
-            (ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const) === 0)
+        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 +1326,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;
@@ -1645,6 +1680,17 @@ 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 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 +1787,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 (SC8020). */
+    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 +1851,10 @@ 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();
+    /** 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 +2417,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 +2464,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 +2575,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
@@ -2518,6 +2588,9 @@ export class Lowerer {
     /** 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 +2603,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 +2707,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 +2789,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 +2813,9 @@ export class Lowerer {
     threadSlotFamilies = new Map();
     /** Classes used as ThreadSlots keys: their hierarchies carry a slot word. */
     threadSlotKeys = new Set();
+    /** 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
@@ -2837,6 +2925,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 +3010,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();
@@ -3166,6 +3261,7 @@ export class Lowerer {
             mapTable("builtinCallableValueFns", this.builtinCallableValueFns),
             mapTable("builtinCallableValueNames", this.builtinCallableValueNames),
             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, () => {
@@ -3212,6 +3308,8 @@ 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),
             checkedTable("typedArgumentsLambdas", () => this.typedArgumentsLambdas.size),
             checkedTable("tupleAliasSymbols", () => this.tupleAliasSymbols.size),
             checkedTable("nullishFuncResults", () => this.nullishFuncResults.size),
@@ -3287,6 +3385,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 +3405,7 @@ export class Lowerer {
             checkedTable("threadSlotNames", () => this.threadSlotNames.size),
             checkedTable("threadSlotFamilies", () => this.threadSlotFamilies.size),
             checkedTable("threadSlotKeys", () => this.threadSlotKeys.size),
+            checkedTable("objectMethodNames", () => this.objectMethodNames.size),
             checkedTable("forkTargetIdByPath", () => this.forkTargetIdByPath.size),
             checkedTable("nsBlocks", () => this.nsBlocks.size),
             checkedTable("initNameOf", () => this.initNameOf.size),
@@ -3320,6 +3420,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),
@@ -3414,10 +3515,12 @@ export class Lowerer {
         "priorRetriedSymbols",
         "wholeSlotDegradation",
         "inferredCollectionTypes",
+        "partialAssertions",
         "foreignElementKeys",
         // caches made when first needed
         "nanCodedReads",
         "mentionsProcessVersions",
+        "createsWrappers",
         "stringIndexBoundsCache",
         "functionLocalSubclasses",
         "socketEncodingReachable",
@@ -3425,8 +3528,13 @@ export class Lowerer {
         "unixListenReachable",
         "streamPropMutatedSyms",
         "readsExitCode",
+        "patchesStdio",
+        "stdioPatchSites",
         "requestInitPropMutatedSyms",
         "classProtocols",
+        // The whole-program prepass analyzeJsWidenedBindings computes this set
+        // before lowering begins: a pure function of the program's modules.
+        "jsWidenedBindings",
         "cjsSplitRequireBindings",
         "cjsWholeExportSymbols",
         "cjsLiveMemberExports",
@@ -3437,6 +3545,7 @@ export class Lowerer {
         "sloppyThisGlobalReads",
         "globalLookupNames",
         "namesWebStreamClass",
+        "typedWebStreams",
         "timeValueDateDecisions",
         "timeValueDateWrites",
         "dynamicOverloadAnswers",
@@ -3446,11 +3555,17 @@ export class Lowerer {
         // 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",
@@ -3508,6 +3623,7 @@ export class Lowerer {
         "neverValued",
         "chainNarrowedType",
         "chainHandled",
+        "spreadArmOverrides",
         "splitIdentifierUses",
         "typeMemo",
         "fnStack",
@@ -3542,10 +3658,14 @@ export class Lowerer {
             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),
@@ -3982,6 +4102,7 @@ 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)
@@ -4077,15 +4198,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) {
@@ -5400,6 +5546,49 @@ 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. */
+    analyzeJsWidenedBindings(parts) {
+        for (const { sf } of parts) {
+            if (!isJsSourceFileName(sf.fileName) || sf.isDeclarationFile)
+                continue;
+            ts.walkPreorder(sf, (node) => {
+                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();
         // The site whose value the current promotion follows (debug only).
@@ -8309,6 +8498,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 +8656,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 +8672,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,
@@ -8493,10 +8689,17 @@ export class Lowerer {
     /** Final retention, pruning, and module assembly shared by ordinary emit
      * and the retained reachability worklist. */
     finishModule(functions) {
+        // 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);
+        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);
@@ -8653,11 +8856,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 (SC8020): 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 +8971,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
@@ -8787,7 +9001,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.
@@ -8823,6 +9037,7 @@ export class Lowerer {
             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
@@ -8834,6 +9049,8 @@ export class Lowerer {
         // 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 +9101,7 @@ export class Lowerer {
                         order: unitOrder++,
                         roots: functionRoots(decl),
                         lower: () => this.lowerFunction(decl),
+                        source: decl,
                     });
                 }
             }
@@ -8906,6 +9124,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 +9133,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 +9149,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 +9158,7 @@ export class Lowerer {
                         order: unitOrder++,
                         roots: [],
                         lower: () => this.throwingSetterFn(info, prop),
+                        source: info.decl ?? undefined,
                     });
                 }
             }
@@ -8944,6 +9168,8 @@ export class Lowerer {
                         order: unitOrder++,
                         roots: functionRoots(entry.member),
                         lower: () => lowerStaticMethod(this, info, name),
+                        source: entry.member,
+                        owners: info.decl ? [info.decl] : [],
                     });
                 }
             }
@@ -9230,17 +9456,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 +9546,7 @@ export class Lowerer {
                     }
                 }
             }
+            held?.check();
         };
         drainUnits();
         this.restoreGenericInstanceOrder();
@@ -9301,6 +9588,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 +9600,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 +9644,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);
@@ -9350,9 +9660,50 @@ export class Lowerer {
         this.reachableForArtifacts = reachable;
         return { reachable, result: this.finishModule(functions) };
     }
+    /** 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 +9735,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 +9808,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 +9901,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 +10176,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 +10188,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
@@ -10083,9 +10479,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",
@@ -10570,8 +10968,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 +11345,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 +11405,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 } : {}),
@@ -12040,6 +12478,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);
@@ -12178,8 +12621,51 @@ 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;
+        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 +12693,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 +12715,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 +12831,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 +12944,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 };
@@ -13739,6 +14251,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`);
+        }
         if (this.isBlockedBinding(symbol)) {
             this.pushDiag(blockedBindingUseDiag(name, locOf(node)));
             throw new PoisonError();
@@ -14355,6 +14875,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 +15372,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) };
@@ -14951,8 +15474,21 @@ export class Lowerer {
                 loc,
             });
         }
+        if (valueParams.some((param) => param.name !== undefined)) {
+            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. */