@scriptc/compiler 0.4.1 → 0.4.3

package/dist/frontend/lowering/lowerer.js

@@ -1,4 +1,9 @@
-import { onlyForwarded } from "./typed-arguments.js";
+import { isDeclBoundaryFile } from "../decl-projection.js";
+import { relieveHeapPressure } from "../../heap-pressure.js";
+import { moduleNamespaceObject } from "./module-namespace-elements.js";
+import { keyedHelperName } from "./stable-names.js";
+import { positionTag, StructuralPositions } from "./structural-positions.js";
+import { 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";
@@ -14,6 +19,8 @@ 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 { 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";
@@ -28,11 +35,13 @@ import { encodeBase64 } from "../../wasm/base64.js";
 import { resolveRequireRuntime } from "../runtime-resolve.js";
 import { lowerKeyObjectCall } from "./builtins/key-object.js";
 import { isEcdhType, lowerEcdhCall } from "./builtins/ecdh.js";
+import { isDiffieHellmanType, lowerDiffieHellmanCall } from "./builtins/dh.js";
 import { fenceWebCryptoMember, lowerWebCryptoCall } from "./builtins/webcrypto.js";
-import { hashStreamOf } from "./builtins/hash-stream.js";
+import { valueStreamOf } from "./builtins/hash-stream.js";
 import { lowerNetAddressCall, lowerNetAddressNew } from "./builtins/net-address.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
 import { iteratorSlotAdapter } from "./iterator-adapters.js";
+import { iterableSlotValue } from "./iterable-values.js";
 import { lowerBuiltinCall } from "./builtin-calls.js";
 import { CoercionState } from "./coercions/state.js";
 import { widthLiftPlan, unitOnlyElem, recordWidthPlan, describeRecordWidthBlocker, objToRecordPlan, recordToClassPlan, } from "./coercions/structural-plans.js";
@@ -49,6 +58,7 @@ import { ArrayElementStates } from "./runtime-optional-elements.js";
 import { indexReadInBounds } from "./runtime-optional-bounds.js";
 import { ArrayOwnership } from "./runtime-optional-ownership.js";
 import { RecordFlowClasses } from "./runtime-optional-records.js";
+import { SiteDependencies } from "./site-dependencies.js";
 import { StringIndexBounds } from "./string-index-bounds.js";
 import { NanCodedReads } from "./nan-coded-reads.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
@@ -61,11 +71,13 @@ import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optio
 import {} from "./class-protocol-dispatch.js";
 import { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-dispatch.js";
 import { guardClassAttributeWrites } from "./class-attributes.js";
+import { guardFrozenWrites, markSloppyRecordWrites } from "./frozen-records.js";
 import { applyHandleProperties } from "./handle-properties.js";
 import { ClassProtocols } from "./class-protocols.js";
 import { earlyReadVarSymbols } from "./var-hoisting.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
 import { assignLegacyTiers } from "../../ir/tiers.js";
+import { dynamicTierWarning } from "./dynamic-tier.js";
 import { promoteJsvals } from "../../ir/jsval.js";
 import { analyzeTiers, dynamicStatementCount, } from "../tier-analysis.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
@@ -87,16 +99,16 @@ export { newFnCtx } from "./function-context.js";
  * - Lexical scoping is resolved here: locals get function-unique ids
  *   ("x.0", "x.1" for shadowing); the IR is scope-flat.
  */
-import { resolve } from "node:path";
+import { dirname, relative, resolve } from "node:path";
 import { bindingSource } from "../binding-source.js";
-import { tsgoPath } from "../dts-paths.js";
+import { compilerOwnedFileName, tsgoPath } from "../dts-paths.js";
 import * as ts from "../ts7/adapter.js";
 import { isBundledShimForwarder } from "../package-shims.js";
 import { erasedTypeOnlyImport } from "../type-only-imports.js";
 import { literalValues } from "../literal-values.js";
 import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
 import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, unsupportedNativeApiDiag, unsupportedPackageValueDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
-import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
+import { 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, fallbackDtsPath, isCheckedJsSourceFile, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, erasedOverloadMemberType, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isOverloadedCallableMemberType, isUnitOnlyTsType, isWorkerHandleType, isFetchHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
@@ -119,7 +131,7 @@ import { completeArgs, wrappedUndefined, undefinedArgFor } from "./call-argument
 import { bodyReturnType, declaredReturnType } from "./function-returns.js";
 import { lowerCall, lowerPromiseMethodCall, lowerFilterNarrowCall } from "./lower-calls.js";
 import { lowerFfiCall, validateFfiImports } from "./native-ffi.js";
-import { isTopLevelFnSymbol, lowerNestedFunctionDecl, lowerLambda, lowerFunction, } from "./lower-functions.js";
+import { isTopLevelFnSymbol, lowerNestedFunctionDecl, lowerLambda, lowerFunction, blockedBodyDiagnostics, } from "./lower-functions.js";
 import { lowerArrayMethodCall } from "./containers/array-methods.js";
 import { fuseArrayPipelines } from "./containers/array-pipelines.js";
 import { lowerMapMethodCall, lowerMapForEachCall, lowerSetMethodCall, lowerSetForEachCall, } from "./containers/collection-methods.js";
@@ -144,10 +156,11 @@ import { lowerBuiltinExtraProperty } from "./builtins/properties.js";
 import { registerPromisifiedBuiltinDecl } from "./builtins/callable-aliases.js";
 import { lowerExecFileAsyncCall } from "./builtins/child-process-async.js";
 import { lowerStringDecoderMethodCall, lowerTextCodecCall } from "./builtins/text-codecs.js";
-import { lowerReadlineMethodCall } from "./builtins/readline.js";
+import { isOptionalReadlineCursorRead, lowerReadlineMethodCall } from "./builtins/readline.js";
 import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, lowerAsyncLocalStorageMethodCall, lowerTracingChannelMethodCall, lowerTracingChannelProperty, } from "./builtins/async-context.js";
 import { lowerDisposableStackNew } from "./builtins/disposable-stack.js";
-import { lowerErrorCodeProperty } from "./builtins/errors.js";
+import { lowerErrorCodeProperty, lowerErrorFunctionCall } from "./builtins/errors.js";
+import { noteDateClassMethods } from "./builtins/date-classes.js";
 import { lowerProcessProperty, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerProcessStreamProperty, } from "./builtins/process.js";
 import { consoleCallMember, consoleMethodMember, isConsoleLog, } from "./builtins/console.js";
 import { lowerConsoleNew } from "./lower-console.js";
@@ -156,7 +169,7 @@ import { dateJsonType, isDateJsonSource, lowerDateCall } from "./builtins/dates.
 import { fsConstantMemberRead, fsConstantsObject, lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, } from "./builtins/constants.js";
 import { lowerStringStaticCall, lowerStringLastIndexOfCall } from "./builtins/strings.js";
 import { lowerPromiseStaticCall } from "./builtins/promises.js";
-import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, lowerLiveWebValue, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
+import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, lowerLiveWebValue, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticTransformStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates, } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty, } from "./lower-test.js";
@@ -164,7 +177,7 @@ import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js"
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerSystemErrorMapValue } from "./lower-system-errors.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr, } from "./lower-comptime.js";
-import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, matchGroupsPatternSource, isGuardedRecordRead, } from "./lower-stmts.js";
+import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, matchGroupsPatternSource, isGuardedRecordRead, holdsEvolvingArray, } from "./lower-stmts.js";
 import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, matchCallbackParamGroupsOf, } from "./lower-exprs.js";
 import { finishOptionalChain, isOptionalChainTail, lowerOptionalChain, } from "./expressions/optional-chains.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, } from "./expressions/object-literals.js";
@@ -247,6 +260,33 @@ function directExternalTypeSpecifiersByFile(externalTypes) {
     }
     return out;
 }
+/** Debugging aid: SCRIPTC_LOWER_SHUFFLE_SEED=<n> lowers each wave of
+ * reachable bodies in an order drawn from that seed instead of discovery
+ * order. Output assembly is ordered independently of it, so any IR
+ * difference between seeds is state one body's lowering leaves for another
+ * (scripts/lowering-order.mjs). */
+function lowerShuffle() {
+    const raw = process.env["SCRIPTC_LOWER_SHUFFLE_SEED"];
+    if (raw === undefined || raw === "")
+        return null;
+    // mulberry32
+    let state = Number.parseInt(raw, 10) >>> 0;
+    const next = () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+    return (wave) => {
+        for (let index = wave.length - 1; index > 0; index--) {
+            const other = Math.floor(next() * (index + 1));
+            const swap = wave[index];
+            wave[index] = wave[other];
+            wave[other] = swap;
+        }
+    };
+}
 /** Build lowering runs as a reachability worklist over the ts.Program:
  *
  * 1. REACHABLE EMIT — a worklist computes the set of reachable bodies.
@@ -264,6 +304,10 @@ function directExternalTypeSpecifiersByFile(externalTypes) {
  * the bodies reachable emit did NOT mark (plus deferred collection
  * diagnostics nothing flushed), reported separately: whole-program analysis without
  * letting unreached code fail builds. */
+/** The closure root of an emit-override specialization body. */
+function emitSpecRoot(spec) {
+    return `%emit.${spec.info.def.name}.${spec.event}.${spec.ordinal}`;
+}
 export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const phaseTiming = process.env["SCRIPTC_TIMING"] === "1";
     const phaseStarted = performance.now();
@@ -453,6 +497,14 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     timing("divergence-scan", { found: divergences.length });
     if (divergences.length > 0)
         result = { ...result, divergences };
+    // The performance warning (SC6101): likely-hot functions of the program
+    // that compile to the dynamic tier because the source leaves them untyped.
+    if (result.module !== null && resultLowerer.dynamicFunctions.length > 0) {
+        const hotDynamic = dynamicTierWarning(resultLowerer, result.module, dirname(entry.fileName));
+        timing("dynamic-tier-scan", { found: hotDynamic === null ? 0 : 1 });
+        if (hotDynamic !== null)
+            result = { ...result, performance: [hotDynamic] };
+    }
     // Contract types (@scriptc/types): written annotations, checked against
     // the IR by the compile pipeline (contracts/check.ts).
     // Acyclic object types name the IR unit the program lowered them to; a
@@ -498,18 +550,28 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     });
     // A program that uses the WebAssembly API carries every module the build
     // can see and translate (wasm/translate.ts); the rest fail at run time
-    // with the CompileError for untranslated bytes.
+    // with a CompileError, which names the reason for the modules the build
+    // saw but does not translate.
     if (result.module !== null && resultLowerer.usesWebAssembly) {
         const bytesByHash = new Map();
         const reports = discoverModules((sha256, bytes) => bytesByHash.set(sha256, bytes));
         const wasmModules = [];
+        const wasmUntranslated = [];
         for (const report of reports) {
             const bytes = bytesByHash.get(report.sha256);
-            if (report.status !== "valid" || bytes === undefined)
+            if (bytes === undefined)
                 continue;
-            wasmModules.push({ sha256: report.sha256, bytes: encodeBase64(bytes) });
+            if (report.status === "valid") {
+                wasmModules.push({ sha256: report.sha256, bytes: encodeBase64(bytes) });
+                continue;
+            }
+            const reason = report.status === "unsupported"
+                ? `it uses ${report.unsupported.join(", ")}, outside the translated WebAssembly feature set`
+                : `it is not a valid module: ${report.error ?? report.status}`;
+            wasmUntranslated.push({ sha256: report.sha256, size: bytes.length, reason });
         }
         result.module.wasmModules = wasmModules;
+        result.module.wasmUntranslated = wasmUntranslated;
         if (resultLowerer.usesWasmCustomSections)
             result.module.wasmCustomSections = true;
         timing("wasm-discovery", { modules: wasmModules.length });
@@ -571,6 +633,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     // travel with them: a failed statement is never left unexplained.
     const covered = {
         ...result,
+        diagnostics: [...result.diagnostics, ...remainder.reachedBlockedBodyDiagnostics],
         stats: { ...result.stats, statementsDynamic },
         unreached: {
             diagnostics: rem.diagnostics,
@@ -1061,6 +1124,10 @@ function monomorphizedImplicit(lowerer, fn) {
         return implicitLocalFnNodeOf(lowerer, binding) !== null;
     return true;
 }
+/** `fns` sorted by name; functions of one name keep their order. */
+function byName(fns) {
+    return [...fns].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+}
 export class Lowerer {
     program;
     entry;
@@ -1091,6 +1158,12 @@ export class Lowerer {
      * pinned values resolve through genericFnOf exactly like top-level
      * generic function declarations (bindingGenericFnInfoOf). */
     bindingGenericFns = new Map();
+    /** Identifiers by spelling, per file, for the generic bindings' use
+     * ordering (runsAfterDeclaration). */
+    bindingIdentifiers = new Map();
+    /** Per JavaScript file, the declarations of the bindings it assigns an
+     * own `toString` (jsAssignsOwnToString in lower-calls.ts). */
+    ownToStringTargets = new Map();
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     neverReassignedCache = new Map();
@@ -1242,6 +1315,35 @@ export class Lowerer {
         });
         this.genericClassInstances.splice(from, tail.length, ...tail);
     }
+    /** The classes in table order. Generic instances are added as bodies
+     * demand them, so they keep the slots they hold and fill them in the
+     * order of their settled demand ranks. */
+    classesInTableOrder() {
+        const all = [...this.classes.values()];
+        const slots = all.flatMap((info, index) => this.genericClassDemandPriority.has(info) ? [index] : []);
+        const ranked = slots
+            .map((index) => all[index])
+            .sort((left, right) => {
+            const a = this.genericClassDemandPriority.get(left).rank;
+            const b = this.genericClassDemandPriority.get(right).rank;
+            return a[0] - b[0] || a[1] - b[1];
+        });
+        slots.forEach((slot, index) => (all[slot] = ranked[index]));
+        return all;
+    }
+    /** The globals in table order. A class's prototype data globals are
+     * added when a body first reads that prototype, so they keep the slots
+     * they hold and fill them in id order. */
+    globalsInTableOrder() {
+        const all = [...this.globalsList];
+        const prototypeData = (global) => global.id.startsWith("%g.%prototype.data.");
+        const slots = all.flatMap((global, index) => (prototypeData(global) ? [index] : []));
+        const sorted = slots
+            .map((index) => all[index])
+            .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+        slots.forEach((slot, index) => (all[slot] = sorted[index]));
+        return all;
+    }
     settleGenericDemandPriorities() {
         const functionQueue = [];
         const classQueue = [];
@@ -1320,9 +1422,18 @@ export class Lowerer {
      * and erased instances). */
     erasingDepth = 0;
     localClassInstantiations = [];
+    /** The function-local classes of the program with an `extends` clause, whether lowering collected
+     * them yet or not (new-target.ts); found on first use. */
+    functionLocalSubclasses = undefined;
     /** Instance types (by checker type id) of the local classes generic
      * factory calls return, and the per-instance class each names. */
     localClassInstanceTypes = new Map();
+    /** A generic factory's instantiated result type → the class value of the
+     * local class it returns (TypeMapperCtx.localClassValue). */
+    localClassValueTypes = new Map();
+    /** While a generic factory instance lowers: its declared result type → the
+     * class value of the local class it returns. */
+    instanceResultClass = null;
     /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed
      * instance body lowers: type-parameter symbol → the bound CHECKER type,
      * consulted where the mapped IrType has already widened away information
@@ -1531,6 +1642,47 @@ export class Lowerer {
         }
         return fallback ?? null;
     }
+    /** A fresh TypeScript data literal (`{ message: "m" }`) passed to a
+     * checked-dynamic parameter of a callee implemented in JavaScript, whose
+     * contract lets it reshape the object: a call through an untyped value, an
+     * untyped parameter of a JavaScript function, or a package-declared
+     * parameter type (a non-library `.d.ts`) that makes one of the literal's
+     * properties optional (zod's `normalizeParams` deletes `params.message`).
+     * No typed alias of a fresh literal exists, so it is built as the plain
+     * object the callee receives instead of a view whose record layout refuses
+     * that delete. Standard-library and TypeScript callees, and literals with
+     * methods or accessors, keep their native storage. */
+    reshapeableContextualLiteral(literal, contextual) {
+        const call = literal.parent;
+        if (call === undefined ||
+            !(ts.isCallExpression(call) || ts.isNewExpression(call)) ||
+            !call.arguments?.nodes.includes(literal) ||
+            literal.properties.nodes.length === 0 ||
+            !literal.properties.nodes.every((prop) => (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) &&
+                (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))))
+            return false;
+        const declaration = this.checker.getResolvedSignature(call)?.declaration;
+        const file = declaration ? ts.getSourceFileOfNode(declaration) : undefined;
+        const untyped = contextual.some((part) => part.flags & ts.TypeFlags.Any);
+        if (file === undefined)
+            return untyped;
+        if (isJsSourceFile(file))
+            return untyped;
+        if (!file.isDeclarationFile || this.isStdlibFile(file))
+            return false;
+        if (untyped)
+            return true;
+        const objects = contextual.filter((part) => part.flags & ts.TypeFlags.Object);
+        if (objects.length === 0)
+            return false;
+        return literal.properties.nodes.some((prop) => {
+            const name = prop.name.text;
+            return objects.every((part) => {
+                const symbol = this.checker.getPropertyOfType(part, name);
+                return symbol !== undefined && (symbol.flags & ts.SymbolFlags.Optional) !== 0;
+            });
+        });
+    }
     /** A TypeScript object literal handed to a JavaScript checked-value
      * parameter whose inferred type is open (`constructor({ factory, ...options
      * } = {})` — the rest element admits any property): the literal names a
@@ -1857,6 +2009,19 @@ export class Lowerer {
     /** True while re-lowering a base function's 2nd+ instance: the same source
      * statements were already counted for the first instance. */
     suppressStats = false;
+    /** Callback literals passed straight to an error-first zlib or crypto
+     * function: only that function's callback adapter calls them
+     * (lowerUndefinedResultBody). */
+    errorFirstLiterals = new Set();
+    /** Parameters read as `any` in the error-path copy of an error-first
+     * callback. */
+    anySymbols = new Set();
+    /** Error parameters of an error-first callback with a known value in
+     * the copy being lowered: true while it holds an Error, false while it
+     * holds null (staticCondition folds conditions on them). */
+    knownErrors = new Map();
+    /** The number of error-path callback copies being lowered. */
+    errorPathCopies = 0;
     /** Comparisons interned by operand representations and equality semantics. */
     equalityHelpers = new Map();
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
@@ -1907,6 +2072,8 @@ export class Lowerer {
     /** Generated value helpers, keyed by operation and type. Callers own
      * their key prefixes; this includes more than structural conversions. */
     valueHelpers = new Map();
+    /** Each name keyedHelperName made, with a second hash of its key. */
+    keyedNameKeys = new Map();
     /** structuralNarrowing's assignable classes, keyed by static and
      * narrowed class name. */
     structuralClassPeers = new Map();
@@ -2021,13 +2188,38 @@ export class Lowerer {
      * `doneLocalId` is sticky: once next() observes the end, later source
      * changes do not revive the exhausted iterator, exactly like Node. */
     numericIterators = new Map();
-    chainCounter = 0;
     /** Keyed by program-wide qualified class name (what IR object types carry). */
     classes = new Map();
     classBySymbol = new Map();
     /** Named method slots observed before class collection need a callable
      * ABI and shared prototype descriptors instead of call-site specialization. */
     prototypeMethodAccesses = new Map();
+    /** Every site the census found for a name in prototypeMethodAccesses (which
+     * keeps one): reads of the method and writes that may replace it. The
+     * key-order witness asks which replacements can return records. */
+    methodAccessSites = new Map();
+    /** Marks `name` as a method the program may read or replace at `site`. */
+    noteMethodAccess(name, site) {
+        this.prototypeMethodAccesses.set(name, site);
+        this.noteMethodSite(name, site);
+    }
+    /** Records a site for `name` without changing its prototypeMethodAccesses entry. */
+    noteMethodSite(name, site) {
+        const sites = this.methodAccessSites.get(name);
+        if (sites === undefined)
+            this.methodAccessSites.set(name, [site]);
+        else
+            sites.push(site);
+    }
+    /** Whether the program reads `Error.prototype`, the checked-dynamic
+     * object an ES5 constructor function can inherit from, or has a class
+     * whose heritage is evaluated at run time (`extends (Base ?? Error)`):
+     * only then can a value that is not an Error instance be
+     * `instanceof Error`. */
+    errorPrototypeValues = false;
+    /** The property names the program assigns on the global object
+     * (property-access.ts), collected on first use. */
+    globalThisWrittenNames = null;
     /** Well-known symbol methods (`sym:iterator`) the program may replace
      * through a symbol-keyed write: an instance or prototype property, or a
      * reflection call. */
@@ -2092,10 +2284,16 @@ export class Lowerer {
     /** Inline Promise.then parameters whose contextual type is a builtin
      * module namespace anonymous object. The settled native token is the
      * ABI truth even when the checker type has no stable module symbol. */
-    /** Receivers of a stream call on a Hash or Hmac (lowerHashStreamCall):
-     * for the duration of that call, the receiver lowers to the Transform of
-     * the value held in the named local. */
-    hashStreamReceivers = new Map();
+    /** Receivers of a stream call on a Hash, Hmac, Cipheriv or Decipheriv
+     * (lowerHashStreamCall): for the duration of that call, the receiver
+     * lowers to the Transform of the value held in the named local. */
+    valueStreamReceivers = new Map();
+    /** fs call arguments evaluated ahead of a URL path's conversion
+     * (builtins/fs-paths.ts): each lowers to the hidden local that holds its
+     * value, which is null until the path's lowering has saved it. */
+    stagedArguments = new Map();
+    /** The staged arguments that follow each such URL path, in order. */
+    stagedAfterPath = new Map();
     moduleNsParamOverrides = new Map();
     /** File → qualifier prefix: "" for the entry, "%mI." otherwise. */
     fileTag = new Map();
@@ -2209,7 +2407,17 @@ export class Lowerer {
     // Stack of function contexts (bottom = the function being declared at
     // top level, top = the innermost nested function currently lowering).
     fnStack = [];
+    /** Source ranges of record writes in sloppy-mode code, and of the
+     * absent-state writes of `delete r.f` (markSloppyRecordWrites). */
+    sloppyRecordWrites = new Set();
+    recordFieldDeletes = new Set();
+    /** typeKeys of the array types the program may freeze (IrModule.freezableArrays). */
+    freezableArrays = new Set();
     liftedFns = [];
+    /** The first lifted function of each name (liftedFnNamed), for the
+     * liftedFns indexed so far. liftedFns only grows. */
+    liftedFnsByName = new Map();
+    liftedFnsIndexed = 0;
     /** Runtime-provided classes used as values (defineClassValueConstruct),
      * by IR class name. */
     runtimeClassValues = new Map();
@@ -2217,7 +2425,57 @@ export class Lowerer {
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision = null;
     errorPropertyDispatchRevision = null;
-    lambdaCounter = 0;
+    /** The program defines properties by reflection on an untyped or
+     * Error-shaped target, so an own accessor may replace an error's `name`
+     * or `message`: typed reads and writes of those slots check for one.
+     * Holds the first such call's location. */
+    errorAccessorReflection = null;
+    /** Structural source positions (structural-positions.ts) for names that
+     * stay the same when unrelated code moves. */
+    /** Files are named by their path relative to the entry's directory, so
+     * names do not depend on where the program sits, default library files
+     * by their base name (two checkers install them in different
+     * directories), and the files scriptc ships by their name inside scriptc,
+     * so names do not depend on where scriptc is installed either. */
+    positions = new StructuralPositions((sf) => this.program.isSourceFileDefaultLibrary(sf)
+        ? `lib:${sf.fileName.slice(sf.fileName.lastIndexOf("/") + 1)}`
+        : (compilerOwnedFileName(sf.fileName) ?? relative(dirname(this.entry.fileName), sf.fileName)));
+    /** The outermost node whose token span is exactly `loc`, or null. */
+    nodeAtLoc(loc) {
+        const sf = this.program.getSourceFile(loc.file);
+        return sf === undefined ? null : (ts.nodeAtSpan(sf, loc.start, loc.end) ?? null);
+    }
+    /** The lowering unit whose name scopes the closures it lifts. */
+    closureRoot = "%pre";
+    closureNameCounts = new Map();
+    /** Runs `fn` with the closures it lifts named under `root`. */
+    withClosureRoot(root, fn) {
+        const previous = this.closureRoot;
+        this.closureRoot = root;
+        try {
+            return fn();
+        }
+        finally {
+            this.closureRoot = previous;
+        }
+    }
+    /** The name of a closure (or wrapper) lifted for the source at `loc`:
+     * `<prefix>.<hash>` of the current lowering unit, the location and
+     * `suffix`, then `suffix`. A unit that lifts several functions for the same
+     * location and suffix numbers them in the order it lifts them, so a
+     * closure's name depends only on its unit, not on which units lowered
+     * before it. */
+    closureName(loc, suffix = "", prefix = "%fn") {
+        const node = this.nodeAtLoc(loc);
+        const where = node === null
+            ? `${compilerOwnedFileName(loc.file) ?? loc.file}:${loc.start}:${loc.end}`
+            : this.positions.of(node);
+        const key = `${prefix}|${this.closureRoot}|${where}|${suffix}`;
+        const first = keyedHelperName(this, prefix, key);
+        const seen = this.closureNameCounts.get(first) ?? 0;
+        this.closureNameCounts.set(first, seen + 1);
+        return (seen === 0 ? first : keyedHelperName(this, prefix, `${key}|${seen}`)) + suffix;
+    }
     preparedClassFactories = new Map();
     preparingClassFactories = new Set();
     /** Statement lists currently mid-lowering, innermost last: the forward-
@@ -2269,6 +2527,13 @@ export class Lowerer {
      * can contain any retained descendant, but importing its declaration
      * alone does not make every descendant constructible. */
     constructedClasses = null;
+    /** Classes added to some ClassInfo's subclasses (lower-classes.ts). With
+     * the class and constructed-class counts, it tells caches over the class
+     * graph when the graph changed. */
+    subclassLinks = 0;
+    /** Function-local classes by the class node they extend, built on first
+     * use (localSubclassesOf in lower-classes.ts). */
+    localSubclassIndex = null;
     /** Set while a subclass constructor's super() call notes its base
      * constructor edge: that edge does not instantiate the base exactly. */
     superConstructorEdge = false;
@@ -2282,6 +2547,149 @@ export class Lowerer {
             info.genericInstance !== undefined ||
             info.mixinInstance !== undefined);
     }
+    /** How many classes classCanBeConstructed admits by name, or -1 while
+     * it admits every class. The count only grows. */
+    constructedClassCount() {
+        return this.constructedClasses?.size ?? -1;
+    }
+    /** Helpers that every site asking for them shares (shareHelper). */
+    sharedHelpers = new Set();
+    sharedHelperNames = new Set();
+    /** Marks a helper, or the lifted helpers of a name, as shared by every
+     * site that asks for it. A shared helper is built for whichever site asks
+     * first, so once lowering finishes its locations are replaced by one that
+     * names no site. */
+    shareHelper(helper) {
+        if (typeof helper === "string")
+            this.sharedHelperNames.add(helper);
+        else
+            this.sharedHelpers.add(helper);
+    }
+    /** Gives each shared helper (those marked by shareHelper, and those
+     * interned by key in the helper tables) one location for all its nodes:
+     * the earliest site in `functions` that uses it, by file and position, so
+     * reports such as --explain-dynamic point at a use whatever order bodies
+     * lowered in. A helper used only by other shared helpers takes their
+     * location; one with no use takes the entry file's start. */
+    settleSharedHelperLocations(functions) {
+        const interned = new Set([...this.sharedHelperNames, ...this.classMethodValueHelpers]);
+        for (const table of [
+            this.equalityHelpers,
+            this.arrHofHelpers,
+            this.unionCallHelpers,
+            this.valueHelpers,
+            this.assertHelpers,
+            this.inspectHelpers,
+            this.iterDrainHelpers,
+            this.mapHofHelpers,
+            this.setHofHelpers,
+            this.spHofHelpers,
+            this.primitiveCtorFns,
+            this.builtinCallableValueFns,
+            this.regionRunHelpers,
+            this.internTableHelpers,
+            this.coercions.retags,
+            this.coercions.narrows,
+        ])
+            for (const name of table.values())
+                interned.add(name);
+        for (const fn of [...this.liftedFns, ...this.implicitFns])
+            if (interned.has(fn.name))
+                this.sharedHelpers.add(fn);
+        if (this.sharedHelpers.size === 0)
+            return;
+        const shared = new Map([...this.sharedHelpers].map((fn) => [fn.name, fn]));
+        // Files scriptc ships compare by their name inside scriptc, so the
+        // choice does not depend on where scriptc is installed.
+        const fileKeys = new Map();
+        const fileKey = (file) => {
+            let key = fileKeys.get(file);
+            if (key === undefined)
+                fileKeys.set(file, (key = compilerOwnedFileName(file) ?? file));
+            return key;
+        };
+        const earlier = (left, right) => {
+            if (left.file === right.file)
+                return left.start < right.start;
+            return fileKey(left.file) < fileKey(right.file);
+        };
+        // The earliest use of each shared helper outside the shared helpers, and
+        // which shared helpers each shared helper uses.
+        const uses = new Map();
+        const usedBy = new Map();
+        for (const fn of functions) {
+            const inShared = shared.has(fn.name) ? fn.name : undefined;
+            everyStmtList(fn.body, {
+                stmt: () => true,
+                expr: (expr) => {
+                    const name = expr.kind === "call" ? expr.callee : exprFunctionReference(expr);
+                    if (name === undefined || name === inShared || !shared.has(name))
+                        return true;
+                    if (inShared !== undefined) {
+                        let users = usedBy.get(name);
+                        if (users === undefined)
+                            usedBy.set(name, (users = new Set()));
+                        users.add(inShared);
+                    }
+                    else {
+                        const current = uses.get(name);
+                        if (current === undefined || earlier(expr.loc, current))
+                            uses.set(name, expr.loc);
+                    }
+                    return true;
+                },
+            });
+        }
+        // Helpers reached only through other shared helpers take the earliest
+        // location among those, to a fixed point.
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const [name, users] of usedBy) {
+                for (const user of users) {
+                    const loc = uses.get(user);
+                    const current = uses.get(name);
+                    if (loc !== undefined && (current === undefined || earlier(loc, current))) {
+                        uses.set(name, loc);
+                        changed = true;
+                    }
+                }
+            }
+        }
+        const fallback = { file: this.entry.fileName, start: 0, end: 0 };
+        for (const fn of this.sharedHelpers) {
+            const use = uses.get(fn.name) ?? fallback;
+            const loc = { file: use.file, start: use.start, end: use.end };
+            const seen = new Set();
+            const visit = (node) => {
+                if (typeof node !== "object" || node === null || seen.has(node))
+                    return;
+                seen.add(node);
+                if (Array.isArray(node)) {
+                    for (const item of node)
+                        visit(item);
+                    return;
+                }
+                const record = node;
+                for (const key of Object.keys(record)) {
+                    if (key === "loc")
+                        record[key] = loc;
+                    else if (key !== "type")
+                        visit(record[key]);
+                }
+            };
+            visit(fn);
+        }
+    }
+    /** The first lifted function named `name`, the one
+     * `liftedFns.find((fn) => fn.name === name)` returns. */
+    liftedFnNamed(name) {
+        for (; this.liftedFnsIndexed < this.liftedFns.length; this.liftedFnsIndexed++) {
+            const fn = this.liftedFns[this.liftedFnsIndexed];
+            if (!this.liftedFnsByName.has(fn.name))
+                this.liftedFnsByName.set(fn.name, fn);
+        }
+        return name === undefined ? undefined : this.liftedFnsByName.get(name);
+    }
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
      * and no module is built. */
     remainder;
@@ -2401,6 +2809,20 @@ export class Lowerer {
         else if (kind === "failed")
             s.failed += 1;
     }
+    /** The program holds the declaration-typed boundary's projection
+     * (decl-projection.ts): user-file record and array values crossing into
+     * dynamic slots (package parameters) box as live capsules, so a value
+     * that comes back through a boundary cast keeps its identity. */
+    declBoundaryMemo = null;
+    get declBoundary() {
+        this.declBoundaryMemo ??= this.program
+            .getSourceFiles()
+            .some((sf) => isDeclBoundaryFile(sf.fileName));
+        return this.declBoundaryMemo;
+    }
+    /** Tracked classes' bag initializers over a typed `this`
+     * (class-dynamic-dispatch.ts recordBagInitializers). */
+    classBagInitializers = new Map();
     constructor(program, entry, moduleOrder, mode = {}) {
         this.program = program;
         this.entry = entry;
@@ -2435,6 +2857,7 @@ export class Lowerer {
         this.checker = program.getTypeChecker();
         this.typeCtx = {
             checker: this.checker,
+            positionOf: (node) => this.positions.of(node),
             shapes: this.shapes,
             unions: this.unions,
             classNamer: this.classNamer,
@@ -2443,6 +2866,9 @@ export class Lowerer {
             isErasing: () => this.erasingDepth > 0,
             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
+                : (this.localClassValueTypes.get(type.id) ?? null),
             mixinClassInstance: (decl) => this.mixinTypeContext && this.mixinTypeContext.classNode === decl
                 ? { kind: "object", className: this.mixinTypeContext.className }
                 : null,
@@ -2500,7 +2926,10 @@ export class Lowerer {
             classImplementedProtocol: (type) => this.classImplementedProtocol(type),
             isStdlibFile: this.isStdlibFile,
             isNpmFile: this.isNpmFile,
-            isExternalTypeFile: (sf) => this.externalTypeSpecifiersByFile.has(tsgoPath(resolve(sf.fileName))),
+            // 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),
             typeMemo: this.typeMemo,
             ...(this.generalNodeStreams ? { generalNodeStreams: true } : {}),
             ...(this.dynNodeStreams ? { dynNodeStreams: true } : {}),
@@ -2561,16 +2990,16 @@ export class Lowerer {
      * is `unknown` or `object` (also with `null` or `undefined`, or an array
      * of those), names checked protocol identity, is an owned runtime
      * handle (a Worker or MessagePort, a fetch Headers/Request/Response, or
-     * a node:crypto ECDH), or is a WeakMap/WeakSet (native weak collections
-     * live in checked-dynamic storage, as locals of those types do); `any`
-     * fields stay refused. */
+     * a node:crypto ECDH, DiffieHellman or DiffieHellmanGroup), or is a
+     * WeakMap/WeakSet (native weak collections live in checked-dynamic
+     * storage, as locals of those types do); `any` fields stay refused. */
     classFieldStoresDyn(type) {
         return (this.opaqueValueType(type) ||
             this.classImplementedProtocol(type) ||
             isWorkerHandleType(type, this.typeCtx) ||
             isFetchHandleType(type, this.typeCtx) ||
             this.weakCollectionType(type) ||
-            this.stdlibHandleType(type, (part) => isEcdhType(this, part)));
+            this.stdlibHandleType(type, (part) => isEcdhType(this, part) || isDiffieHellmanType(this, part)));
     }
     /** A stdlib WeakMap or WeakSet, alone or with `null`/`undefined`. */
     weakCollectionType(type) {
@@ -2670,8 +3099,8 @@ export class Lowerer {
                 }
                 return false;
             })()
-            ? this.qualify(ts.getSourceFileOfNode(decl), `%cx${ts.tokenStartOfNode(decl)}.${decl.name?.text ?? ""}`)
-            : this.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"));
+            ? this.qualify(ts.getSourceFileOfNode(decl), `%cx${positionTag(this, decl)}.${decl.name?.text ?? ""}`)
+            : this.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(this, decl) + (decl.name ? decl.name.text : "%anon"));
         for (let index = this.localClassInstantiations.length - 1; index >= 0; index--) {
             const entry = this.localClassInstantiations[index];
             for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
@@ -3760,11 +4189,16 @@ export class Lowerer {
         // resolveValueSymbol also flushes deferred diagnostics and applies
         // merged-namespace fences, whose authority remains ordinary lowering.
         this.checker.prefetchSymbolRoots(sourceFiles, true);
+        // The facts each fixed-point site reads, by the symbols, nodes and
+        // element keys they belong to (created with the site list below).
+        let siteDependencies = null;
         const symbolOf = (node) => {
             const s = this.checker.getSymbolAtLocation(node);
             if (!s)
                 return null;
-            return s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s;
+            const symbol = s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s;
+            siteDependencies?.read(symbol);
+            return symbol;
         };
         const signatureOf = (node) => {
             const symbol = symbolOf(node);
@@ -3932,8 +4366,11 @@ export class Lowerer {
         const callableSymbols = new Map();
         const callableSymbolOf = (node) => {
             const cached = callableSymbols.get(node);
-            if (cached !== undefined)
+            if (cached !== undefined) {
+                if (cached !== null)
+                    siteDependencies?.read(cached);
                 return cached;
+            }
             let symbol = symbolOf(ts.isPropertyAccessExpression(node) ? node.name : node);
             if (symbol === null || signatureBySymbol.has(symbol)) {
                 callableSymbols.set(node, symbol);
@@ -4235,14 +4672,19 @@ export class Lowerer {
                 return true;
             if (ts.isPropertyAccessExpression(e) && isOptionalProcessStreamProperty(this, e))
                 return true;
+            if (ts.isPropertyAccessExpression(e) && isOptionalReadlineCursorRead(this, e))
+                return true;
             if (isOptionalProcessVersionsRead(this, e))
                 return true;
             if (ts.isPropertyAccessExpression(e) && isSettledIteratorValueRead(this, e))
                 return true;
             if (ts.isPropertyAccessExpression(e) && isOsConstantsSymbol(symbolOf(e.expression), this))
                 return true;
-            if (ts.isCallExpression(e) && this.runtimeOptionalReduceTypes.has(e))
-                return true;
+            if (ts.isCallExpression(e)) {
+                siteDependencies?.read(e);
+                if (this.runtimeOptionalReduceTypes.has(e))
+                    return true;
+            }
             if (ts.isCallExpression(e) &&
                 e.arguments.nodes.length === 0 &&
                 ts.isPropertyAccessExpression(e.expression) &&
@@ -4747,6 +5189,7 @@ export class Lowerer {
                 if (fnType?.kind === "func" && bodyReturnsOptional(fn)) {
                     const widenedReturn = this.runtimeOptionalType(fnType.ret);
                     provenance?.note("callback-return", fn, provenanceSite);
+                    siteDependencies?.read(fn);
                     const previousReturn = this.runtimeOptionalFunctionReturnType(fn, fnType.ret);
                     this.runtimeOptionalFunctionReturns.set(fn, widenedReturn);
                     if (!typeEquals(previousReturn, widenedReturn))
@@ -4989,8 +5432,11 @@ export class Lowerer {
                 const key = typeKey(arm.elem);
                 if (arm.elem.kind === "union"
                     ? this.armTag(arm.elem.unionId, UNDEFINED_T) >= 0
-                    : isUnitType(arm.elem) || arm.elem.kind === "void")
+                    : isUnitType(arm.elem) || arm.elem.kind === "void") {
+                    if (!optionalElementKeys.has(key))
+                        siteDependencies?.changed(key);
                     optionalElementKeys.add(key);
+                }
                 keys.push(key);
             }
             return keys;
@@ -5102,7 +5548,10 @@ export class Lowerer {
             return keys;
         };
         const elementStates = new ArrayElementStates({
-            elementAdmitsUndefined: (key) => optionalElementKeys.has(key),
+            elementAdmitsUndefined: (key) => {
+                siteDependencies?.read(key);
+                return optionalElementKeys.has(key);
+            },
             ownerOf: (node) => ownership.ownerOf(node),
             allocationOwner: (node) => ownership.allocationOwner(node),
             arrayKeys: arrayKeysOf,
@@ -5177,6 +5626,8 @@ export class Lowerer {
             note: provenance
                 ? (fact, key, site) => provenance.note(`element-${fact}`, site, site, key)
                 : null,
+            read: (fact) => siteDependencies?.read(fact),
+            changed: (fact) => siteDependencies?.changed(fact),
         });
         // Each pass revisits every array callback site; the last visit holds
         // the decision at the fixed point.
@@ -5404,7 +5855,10 @@ export class Lowerer {
                 }
                 if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
                     const callbackIndices = hofCallbackIndices(node.expression.name.text, node.arguments.nodes.length >= 2);
-                    const callback = node.arguments.nodes[0];
+                    // `xs.map(((x) => x))`: the parenthesized callback is the arrow.
+                    let callback = node.arguments.nodes[0];
+                    while (callback !== undefined && ts.isParenthesizedExpression(callback))
+                        callback = callback.expression;
                     if (callbackIndices !== null && callback !== undefined && !ts.isSpreadElement(callback)) {
                         const receiverNode = node.expression.expression;
                         const receiverTs = this.typeOf(receiverNode);
@@ -5455,12 +5909,27 @@ export class Lowerer {
                             presentSites.set(node, elementsPresent && !reduce);
                             if (elementsPresent && reduce && retypeInlineCallback(callback, callbackIndices))
                                 changed = true;
-                            if ((method === "reduce" || method === "reduceRight") &&
-                                ((!elementsPresent && node.arguments.nodes.length < 2) ||
-                                    callbackReturnsOptional(callback))) {
-                                if (promoteHofCallback(callback, [0, 1]))
+                            // The accumulator holds undefined when the callback can return
+                            // it, when an initial value can be missing, or when elements can
+                            // be absent and there is no initial value. It holds another
+                            // primitive when the callback's result can be one at run time
+                            // (`missing[0] ?? "fallback"`).
+                            const initial = node.arguments.nodes[1];
+                            const optional = (!elementsPresent && initial === undefined) ||
+                                (initial !== undefined && !ts.isSpreadElement(initial) && mayBeOptional(initial)) ||
+                                callbackReturnsOptional(callback);
+                            const arithmetic = reduce && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))
+                                ? lambdaArithmeticReturn(callback)
+                                : null;
+                            if (reduce && (optional || arithmetic !== null)) {
+                                if (optional && promoteHofCallback(callback, [0, 1]))
                                     changed = true;
-                                const result = this.runtimeOptionalType(this.irTypeOf(node));
+                                let result = this.irTypeOf(node);
+                                if (arithmetic !== null)
+                                    result = joinPrimitiveTypes([result, arithmetic]) ?? result;
+                                if (optional)
+                                    result = this.runtimeOptionalType(result);
+                                siteDependencies?.read(node);
                                 const previous = this.runtimeOptionalReduceTypes.get(node);
                                 if (!previous || !typeEquals(previous, result)) {
                                     this.runtimeOptionalReduceTypes.set(node, result);
@@ -5518,6 +5987,7 @@ export class Lowerer {
                                 (this.typeOf(arg).flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) === 0)
                                 continue;
                             for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                                siteDependencies?.read(target);
                                 const shape = signatureBySymbol.get(target)?.params[i];
                                 if (!shape || shape.mode !== "required")
                                     continue;
@@ -5557,6 +6027,7 @@ export class Lowerer {
                         if (!ts.isSpreadElement(arg) && shape && i !== restAt && fieldsOfValue(arg)) {
                             const fields = fieldsOfValue(arg);
                             for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                                siteDependencies?.read(target);
                                 const parameterShape = signatureBySymbol.get(target)?.params[i];
                                 const parameter = functionDeclBySymbol.get(target)?.parameters?.nodes[i];
                                 if (!parameterShape || parameterShape.type.kind !== "record")
@@ -5608,6 +6079,7 @@ export class Lowerer {
                             // argument can make its elements undefined, not the pack.
                             // Keep every virtual implementation on the same array ABI.
                             for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                                siteDependencies?.read(target);
                                 const rest = signatureBySymbol.get(target)?.params[i];
                                 if (rest?.mode !== "rest" || rest.type.kind !== "array")
                                     continue;
@@ -5632,6 +6104,7 @@ export class Lowerer {
                         // downstream calls and returns see the same optional value.
                         const family = familyBySymbol.get(symbol);
                         for (const target of family ?? [symbol]) {
+                            siteDependencies?.read(target);
                             const parameterShape = signatureBySymbol.get(target)?.params[i];
                             if (!parameterShape)
                                 continue;
@@ -5658,9 +6131,23 @@ export class Lowerer {
                     });
                 }
             };
-            for (const node of sitesOf(sf))
-                scan(node);
-            return changed;
+            // A site whose facts are unchanged since its last visit would compute
+            // that visit's result again, except in a full pass.
+            const base = siteBase.get(sf);
+            const dependencies = siteDependencies;
+            const sites = sitesOf(sf);
+            let fileChanged = false;
+            for (let i = 0; i < sites.length; i++) {
+                if (!fullPass && !dependencies.isStale(base + i))
+                    continue;
+                changed = false;
+                dependencies.begin(base + i);
+                scan(sites[i]);
+                dependencies.end(changed);
+                if (changed)
+                    fileChanged = true;
+            }
+            return fileChanged;
         };
         const scanReturns = (symbol, decl) => {
             let changed = false;
@@ -5711,12 +6198,26 @@ export class Lowerer {
             optionalSymbols.add(symbol);
             this.earlyReadVars.add(symbol);
         }
-        let changed = true;
-        while (changed) {
+        // Number the sites of every file. The first and the last pass visit
+        // every site; the passes between visit only the sites whose facts
+        // changed (SiteDependencies). When such a pass changes nothing, a full
+        // pass confirms the fixed point, and the iteration resumes if it
+        // changes a fact after all.
+        const siteBase = new Map();
+        let siteCount = 0;
+        for (const sf of sourceFiles) {
+            siteBase.set(sf, siteCount);
+            siteCount += sitesOf(sf).length;
+        }
+        siteDependencies = new SiteDependencies(siteCount);
+        let fullPass = true;
+        for (let changed = true, first = true; changed || !fullPass; first = false) {
+            fullPass = first || !changed;
             changed = false;
             for (const [symbol, field] of staticFieldsBySymbol) {
                 if (!optionalSymbols.has(symbol) && mayBeOptional(field.initializer)) {
                     optionalSymbols.add(symbol);
+                    siteDependencies.changed(symbol);
                     provenance?.note("static-field", field.initializer.parent, field.initializer);
                     changed = true;
                 }
@@ -5724,15 +6225,19 @@ export class Lowerer {
             for (const sf of sourceFiles)
                 if (scanFile(sf))
                     changed = true;
-            for (const [symbol, decl] of functionDeclBySymbol)
-                if (scanReturns(symbol, decl))
-                    changed = true;
+            for (const [symbol, decl] of functionDeclBySymbol) {
+                if (!scanReturns(symbol, decl))
+                    continue;
+                siteDependencies.changed(symbol);
+                changed = true;
+            }
             const noteGenericReturn = (symbol, decl) => {
                 if (optionalReturns.has(symbol) || isJsSourceFile(ts.getSourceFileOfNode(decl)))
                     return;
                 if (!returnsOf(decl).some(genericMayBeOptional))
                     return;
                 optionalReturns.add(symbol);
+                siteDependencies.changed(symbol);
                 this.runtimeOptionalGenericReturns.add(decl);
                 provenance?.note("return", decl.name ?? decl, decl);
                 changed = true;
@@ -5770,6 +6275,7 @@ export class Lowerer {
                         : previous;
                 if (!typeEquals(previous, next)) {
                     this.runtimeOptionalFunctionReturns.set(fn, next);
+                    siteDependencies.changed(fn);
                     provenance?.note("lambda-return", fn, fn.body);
                     changed = true;
                 }
@@ -5785,11 +6291,13 @@ export class Lowerer {
                     if (symbol && next.kind === "union" && this.armTag(next.unionId, UNDEFINED_T) >= 0) {
                         if (!optionalReturns.has(symbol)) {
                             optionalReturns.add(symbol);
+                            siteDependencies.changed(symbol);
                             changed = true;
                         }
                     }
                     else if (symbol && !arithmeticReturns.has(symbol)) {
                         arithmeticReturns.set(symbol, next);
+                        siteDependencies.changed(symbol);
                         changed = true;
                     }
                 }
@@ -5808,6 +6316,7 @@ export class Lowerer {
                     : this.runtimeOptionalType(previous);
                 if (!typeEquals(previous, next)) {
                     this.runtimeOptionalFunctionReturns.set(fn, next);
+                    siteDependencies.changed(fn);
                     changed = true;
                 }
             }
@@ -5822,6 +6331,7 @@ export class Lowerer {
                 for (const symbol of optional ? family : []) {
                     if (!optionalReturns.has(symbol)) {
                         optionalReturns.add(symbol);
+                        siteDependencies.changed(symbol);
                         provenance?.note("return", functionDeclBySymbol.get(symbol), undefined, "(override family)");
                         changed = true;
                     }
@@ -5838,10 +6348,14 @@ export class Lowerer {
                     if (previous && typeEquals(previous, joined))
                         continue;
                     arithmeticReturns.set(symbol, joined);
+                    siteDependencies.changed(symbol);
                     changed = true;
                 }
             }
         }
+        // The site facts serve only the fixed point; release them for the rest
+        // of lowering.
+        siteDependencies = null;
         // NaN-coded slots convert optional values on entry instead of holding
         // the union, so promotion never applies to them.
         for (const symbol of [...optionalSymbols])
@@ -6189,13 +6703,16 @@ export class Lowerer {
                 const fn = this.lowerFunction(decl);
                 if (fn)
                     functions.push(fn);
-                else if (this.countsSkips())
+                else if (this.countsSkips()) {
                     this.countSkippedBody(decl);
+                    if (this.remainder)
+                        this.reportBlockedBody(decl);
+                }
             }
             for (const decl of fp.classDecls) {
                 const info = this.classes.get(this.classNamer(decl));
                 if (info)
-                    functions.push(...this.lowerClassMembers(info));
+                    functions.push(...this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)));
                 else if (this.countsSkips())
                     this.countSkippedBody(decl);
             }
@@ -6208,7 +6725,8 @@ export class Lowerer {
         // are reachable by definition, already counted by reachable emit.
         if (!this.remainder) {
             for (const fp of parts) {
-                functions.push(this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)));
+                const initName = this.initNameOf.get(fp.sf);
+                functions.push(this.withClosureRoot(initName, () => this.lowerFileInit(fp.sf, fp.topStmts, initName)));
             }
             functions.push(this.buildMain());
         }
@@ -6248,7 +6766,7 @@ export class Lowerer {
                     // default): the diagnostic is recorded — the instance skips
                     // like a signature-blocked function (lowerFunction's rule).
                     try {
-                        functions.push(this.lowerGenericInstance(info, inst));
+                        functions.push(this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)));
                     }
                     catch (e) {
                         if (!(e instanceof PoisonError))
@@ -6260,7 +6778,8 @@ export class Lowerer {
                 // instances of its own; the joint fixpoint covers both).
                 while (es < this.emitSpecQueue.length) {
                     try {
-                        const fn = lowerEmitOverrideSpec(this, this.emitSpecQueue[es++]);
+                        const spec = this.emitSpecQueue[es++];
+                        const fn = this.withClosureRoot(emitSpecRoot(spec), () => lowerEmitOverrideSpec(this, spec));
                         if (fn)
                             functions.push(fn);
                     }
@@ -6278,6 +6797,7 @@ export class Lowerer {
         // Lambdas lifted while lowering any of the above (plus synthetic
         // 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));
@@ -6311,6 +6831,7 @@ export class Lowerer {
         finalizePrivateBrands(this, functions);
         trackClassFieldCreation(this, functions);
         guardClassAttributeWrites(this, functions);
+        guardFrozenWrites(this, functions);
         applyHandleProperties(this, functions);
         // Globals typed by a class that never REGISTERED (a JS class whose
         // collection fenced — Symbol-keyed fields, an unsupported base): the
@@ -6409,13 +6930,17 @@ export class Lowerer {
                 classes: artifacts.classes,
                 records: artifacts.records,
                 unions: artifacts.unions,
-                globals: this.globalsList,
+                globals: this.globalsInTableOrder(),
                 entry: ENTRY_NAME,
                 ...(this.usesWorkers ? { workers: true } : {}),
                 ...(this.usesLifetimeRegions ? { lifetimeRegions: true } : {}),
+                ...(this.declBoundary ? { declBoundary: true } : {}),
                 ...(this.threadSlotKeys.size > 0
                     ? { threadSlotKeys: [...this.threadSlotKeys].sort() }
                     : {}),
+                ...(this.freezableArrays.size > 0
+                    ? { freezableArrays: [...this.freezableArrays].sort() }
+                    : {}),
                 ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
             };
@@ -6516,6 +7041,20 @@ export class Lowerer {
             this.bumpFileStat(file, "failed");
         }
     }
+    /** Coverage remainder: the body diagnostics of a function whose
+     * signature blocked (blockedBodyDiagnostics). A function reachable emit
+     * reached (its signature's diagnostics flushed there) reports them with
+     * the reached diagnostics; any other reports them as unreached. */
+    reachedBlockedBodyDiagnostics = [];
+    reportBlockedBody(decl) {
+        const diags = blockedBodyDiagnostics(this, decl);
+        const symbol = declSymbolOf(this, decl);
+        if (symbol && this.alreadyFlushed.has(symbol))
+            this.reachedBlockedBodyDiagnostics.push(...diags);
+        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
      * remainder do; an externally-gated emit pass leaves the counting to the
@@ -6538,6 +7077,10 @@ export class Lowerer {
      * body; both fire edges through the same hooks and are not units
      * themselves. */
     emitReachable(extraRoots) {
+        // 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.
+        observeRecordLiteralRebuilds((from, to) => this.keyOrder.follow(from, to));
         this.deferredModuleInitializers = new DeferredModuleInitializers();
         const parts = this.splitFiles();
         this.narrowing.setFiles(parts.map((fp) => fp.sf));
@@ -6790,7 +7333,8 @@ export class Lowerer {
                             rank: [4, instanceMetadataOrder++],
                         };
                         this.genericClassDemandPriority.set(info, ref);
-                        instanceFunctions.push(...this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.lowerClassMembers(info))));
+                        instanceFunctions.push(...this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.withClosureRoot(info.def.name, () => this.lowerClassMembers(info)))));
+                        relieveHeapPressure();
                     }
                 }
                 while (instLowered < this.instantiationQueue.length) {
@@ -6809,7 +7353,8 @@ export class Lowerer {
                         // Body-level poisons skip the instance after retaining the
                         // diagnostic and every edge fired before poisoning.
                         try {
-                            instanceFunctions.push(this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.lowerGenericInstance(info, inst))));
+                            instanceFunctions.push(this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.withClosureRoot(inst.name, () => this.lowerGenericInstance(info, inst)))));
+                            relieveHeapPressure();
                         }
                         catch (e) {
                             if (!(e instanceof PoisonError))
@@ -6822,12 +7367,21 @@ export class Lowerer {
                 // exactly like generic instances.
                 while (specLowered < this.emitSpecQueue.length) {
                     const waveEnd = this.emitSpecQueue.length;
+                    // A wave's specializations lower by class and event, not in the
+                    // order bodies asked for them.
+                    const wave = this.emitSpecQueue.slice(specLowered, waveEnd);
+                    const specKey = ({ info, event }) => `${info.def.name}\0${event}`;
+                    wave.sort((left, right) => specKey(left) < specKey(right) ? -1 : specKey(left) > specKey(right) ? 1 : 0);
+                    this.emitSpecQueue.splice(specLowered, wave.length, ...wave);
                     this.checker.prefetchRoots(this.emitSpecQueue
                         .slice(specLowered, waveEnd)
                         .flatMap(({ info }) => info.emitOverride ? functionRoots(info.emitOverride.decl) : []));
                     while (specLowered < waveEnd) {
                         try {
-                            const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]));
+                            const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => {
+                                const spec = this.emitSpecQueue[specLowered++];
+                                return this.withClosureRoot(emitSpecRoot(spec), () => lowerEmitOverrideSpec(this, spec));
+                            });
                             if (fn)
                                 instanceFunctions.push(fn);
                         }
@@ -6854,7 +7408,7 @@ export class Lowerer {
         parts.forEach((fp, index) => {
             const priority = [2, index];
             const owner = demandOwner(priority);
-            initFunctions.push(this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf)))));
+            initFunctions.push(this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => this.withClosureRoot(this.initNameOf.get(fp.sf), () => this.lowerFileInit(fp.sf, fp.topStmts, this.initNameOf.get(fp.sf))))));
         });
         // LIBRARY mode's extra reachability roots (LowerOptions.libRoots): the
         // profile-mapped exports are called from outside the graph, so they
@@ -6862,9 +7416,11 @@ export class Lowerer {
         // (the export-map resolution reports them as SC4002 later).
         for (const root of extraRoots ?? [])
             this.onEdge?.(root);
+        const shuffle = lowerShuffle();
         const drainUnits = () => {
             while (queue.length > 0) {
                 const wave = queue.splice(0);
+                shuffle?.(wave);
                 this.checker.prefetchRoots(wave.flatMap((name) => units.get(name).roots));
                 for (const name of wave) {
                     // A body-level poison outside the per-statement catches (a fenced
@@ -6875,9 +7431,10 @@ export class Lowerer {
                         const unit = units.get(name);
                         const priority = metadataPriority.get(name) ?? [3, expressionMetadataOrder++];
                         const owner = demandOwner(priority);
-                        const fn = this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, unit.lower));
+                        const fn = this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, () => this.withClosureRoot(name, unit.lower)));
                         if (fn)
                             loweredUnits.set(name, fn);
+                        relieveHeapPressure();
                     }
                     catch (e) {
                         if (!(e instanceof PoisonError))
@@ -6893,22 +7450,29 @@ export class Lowerer {
         // turn queue more instances. Continue to the joint fixpoint; the initial
         // queue above is the only portion whose discovery order differed from
         // historical emit order.
+        noteDateClassMethods(this);
         const classDispatch = new ClassDynamicDispatch(extraRoots !== undefined);
+        // Units in declaration order, so the passes below meet functions, and the
+        // classes they collect, in an order that does not depend on lowering order.
+        const unitsInOrder = () => [...loweredUnits]
+            .sort(([left], [right]) => units.get(left).order - units.get(right).order)
+            .map(([, fn]) => fn);
         for (;;) {
             drainInstances();
+            const declared = unitsInOrder();
             const initializerChanged = this.deferredModuleInitializers.process(this, [
-                ...loweredUnits.values(),
+                ...declared,
                 ...initFunctions,
                 ...instanceFunctions,
-                ...this.liftedFns,
-                ...this.implicitFns,
-            ]);
+                ...byName(this.liftedFns),
+                ...byName(this.implicitFns),
+            ], (fn) => classDispatch.sites.forget(fn));
             const dispatchChanged = classDispatch.process(this, [
-                ...loweredUnits.values(),
+                ...declared,
                 ...initFunctions,
                 ...instanceFunctions,
-                ...this.liftedFns,
-                ...this.implicitFns,
+                ...byName(this.liftedFns),
+                ...byName(this.implicitFns),
             ]);
             if (queue.length === 0 && !dispatchChanged && !initializerChanged)
                 break;
@@ -6917,9 +7481,7 @@ export class Lowerer {
             this.restoreGenericClassInstanceOrder(clsInstLowered);
         }
         classDispatch.finalize(this);
-        const orderedUnits = [...loweredUnits]
-            .sort(([left], [right]) => units.get(left).order - units.get(right).order)
-            .map(([, fn]) => fn);
+        const orderedUnits = unitsInOrder();
         this.settleGenericDemandPriorities();
         this.shapes.settleDeclaredOrderPriorities();
         for (const finalize of this.shapeOrderMetadataFinalizers)
@@ -6931,15 +7493,25 @@ export class Lowerer {
             ...this.liftedFns,
             ...this.implicitFns,
         ]);
+        observeRecordLiteralRebuilds(null);
         for (const finalize of this.shapeOrderHelperFinalizers)
             finalize();
-        const functions = [
+        this.settleSharedHelperLocations([
             ...orderedUnits,
             ...initFunctions,
-            this.buildMain(),
             ...instanceFunctions,
             ...this.liftedFns,
             ...this.implicitFns,
+        ]);
+        // Lifted and implicit functions are created in lowering order; they
+        // are assembled by name.
+        const functions = [
+            ...orderedUnits,
+            ...initFunctions,
+            this.buildMain(),
+            ...instanceFunctions,
+            ...byName(this.liftedFns),
+            ...byName(this.implicitFns),
         ];
         functions.push(...runtimeClassConstructs(this, functions));
         if (this.regexGroupResults)
@@ -7323,7 +7895,36 @@ export class Lowerer {
     fenceStaticReadableStreamMember(access, use) {
         return fenceStaticReadableStreamMember(this, access, use);
     }
+    /** Whether `node` reads an anySymbols parameter, or a member, element or
+     * call result of one: the error-path copy of a callback reads those as
+     * `any`. */
+    readsAnySymbol(node) {
+        let base = node;
+        for (;;) {
+            if (ts.isPropertyAccessExpression(base) ||
+                ts.isElementAccessExpression(base) ||
+                ts.isNonNullExpression(base) ||
+                ts.isParenthesizedExpression(base)) {
+                base = base.expression;
+            }
+            else if (ts.isCallExpression(base) && ts.isPropertyAccessExpression(base.expression)) {
+                base = base.expression.expression;
+            }
+            else {
+                break;
+            }
+        }
+        if (!ts.isIdentifier(base))
+            return false;
+        const parent = base.parent;
+        const symbol = parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === base
+            ? this.checker.getShorthandAssignmentValueSymbol(parent)
+            : this.checker.getSymbolAtLocation(base);
+        return symbol !== undefined && this.anySymbols.has(symbol);
+    }
     typeOf(node) {
+        if (this.anySymbols.size > 0 && this.readsAnySymbol(node))
+            return this.checker.getAnyType();
         if (ts.isPropertyAccessExpression(node) && isJsSourceFile(ts.getSourceFileOfNode(node))) {
             const receiver = node.expression.kind === ts.SyntaxKind.ThisKeyword && this.fnStack.length > 0
                 ? this.resolveThis()?.type
@@ -7598,8 +8199,9 @@ export class Lowerer {
     /** The ts-level twin of typeParamResolver: the bound CHECKER type of a
      * type parameter in the current instantiation (typeParamTsBindings), for
      * the resolutions where mapType's widening already dropped what the body
-     * needs (indexed accesses over literal-bound keys). Inert outside
-     * call-keyed generic instantiation. */
+     * needs (indexed accesses over literal-bound keys, conditional types
+     * over literal arguments). Inert outside generic function and class
+     * instantiation. */
     typeParamTsResolver = (t) => {
         if (!this.typeParamTsBindings || !(t.flags & ts.TypeFlags.TypeParameter))
             return null;
@@ -7750,6 +8352,22 @@ export class Lowerer {
      * type-mapper.ts's chalk-shape mapping — call paths and func-slot coercions
      * share it. */
     hybridCallUnwrap(expr) {
+        // A callable CLASS instance: a class whose merged interface carries a
+        // call signature stores its call behavior in a `%call` field (the
+        // chalk package shim's builder). Calls read the field.
+        if (expr.type.kind === "object") {
+            const callType = this.classes.get(expr.type.className)?.fields.get("%call");
+            if (callType === undefined || callType.kind !== "func")
+                return expr;
+            return {
+                kind: "fieldGet",
+                obj: expr,
+                className: expr.type.className,
+                field: "%call",
+                type: callType,
+                loc: expr.loc,
+            };
+        }
         if (expr.type.kind !== "record")
             return expr;
         const shape = this.shapes.get(expr.type.shapeId);
@@ -7832,6 +8450,20 @@ export class Lowerer {
         }
         if (expr.type.kind === "void" && expected.kind !== "void" && this.neverValued.has(expr))
             return this.divergentValue(expr, expected);
+        // A builtin error constructor global stored in a slot of its class value
+        // type (`{ Parent: Error }`): the class value itself, which a checked
+        // cast of the dynamic constructor value could not produce.
+        if (expected.kind === "classval" &&
+            expr.kind === "libCall" &&
+            expr.fn === "dyn.globalConstructor" &&
+            expr.args[0]?.kind === "strLit" &&
+            `%${expr.args[0].value}` === expected.className) {
+            const info = this.classes.get(expected.className);
+            if (info?.builtinError && info.valueCtorParams !== undefined) {
+                this.defineClassValueConstruct(info);
+                return { kind: "classRef", className: info.def.name, type: expected, loc: expr.loc };
+            }
+        }
         // process.stdout/stderr into a general Writable slot (general-streams.ts).
         const stdioStream = stdioIntoGeneralStream(this, expr, expected);
         if (stdioStream)
@@ -7843,6 +8475,12 @@ export class Lowerer {
             if (adapted)
                 return adapted;
         }
+        // Iterable-typed slots: other iterators enter the generator arm.
+        if (expected.kind === "union" && !typeEquals(expr.type, expected)) {
+            const iterable = iterableSlotValue(this, expr, expected);
+            if (iterable)
+                return iterable;
+        }
         // an any-typed slot marshals implicitly (tsc allows the assignment;
         // the marshal is where its semantics live). OUT: an 'any' value
         // flowing into a typed slot compiles to a VALIDATED exit — like every
@@ -7923,6 +8561,11 @@ export class Lowerer {
             // constructor. `require("events")` is the EventEmitter class itself,
             // so its module binding is too (`ReleaseEmitter = EventEmitter` over
             // `const EventEmitter = require("events")`).
+            if (expr.type.kind === "moduleNs" && isJsSourceFileName(expr.loc.file)) {
+                const object = moduleNamespaceObject(this, expr);
+                if (object)
+                    return object;
+            }
             if (expr.type.kind === "moduleNs" &&
                 expr.type.moduleId === "builtin:events" &&
                 isJsSourceFileName(expr.loc.file)) {
@@ -8030,10 +8673,19 @@ export class Lowerer {
         // A HYBRID (function-with-properties) record flowing into a plain
         // func slot extracts its reserved %call field — the chalk shape's
         // "the value IS callable" half (type-mapper.ts's hybrid mapping).
-        if (expected.kind === "func" && expr.type.kind === "record") {
+        if (expected.kind === "func" && (expr.type.kind === "record" || expr.type.kind === "object")) {
             const un = this.hybridCallUnwrap(expr);
             if (un !== expr && typeEquals(un.type, expected))
                 return un;
+            // A callable class instance (the chalk shim's variadic builder) in a
+            // narrower function slot: its call closure crosses the checked
+            // function boundary, which adapts the arity.
+            if (un !== expr &&
+                expr.type.kind === "object" &&
+                un.type.kind === "func" &&
+                canBoxFuncIntoDyn(un.type, (id) => this.shapes.get(id), (id) => this.unions.get(id))) {
+                return this.coerceToExpected({ kind: "dynFrom", value: un, type: DYN, loc: un.loc }, expected);
+            }
         }
         // A zero-param function whose RETURN is a wider record array than the
         // slot's (`getRoutes: () => cachedRoutes` against `() => Narrow[]`):
@@ -8453,6 +9105,19 @@ export class Lowerer {
      * directly when the expression was already lowered. */
     coerceInto(node, expr, expected) {
         refuseInferredCallbackDrops(this, node, expr.type, expected);
+        // An assertion's scalar check whose value goes straight back into a
+        // checked-dynamic slot (`process.loadEnvFile({} as unknown as string)`)
+        // keeps the original value: JavaScript erases assertions, so the check
+        // could only add a TypeError Node does not throw, and the slot holds
+        // the value either way.
+        if (expected.kind === "dyn" && expr.kind === "dynCheck" && expr.value.type.kind === "dyn") {
+            let source = node;
+            while (ts.isParenthesizedExpression(source))
+                source = source.expression;
+            if ((ts.isAsExpression(source) || ts.isTypeAssertion(source)) &&
+                (expr.type.kind === "string" || expr.type.kind === "f64" || expr.type.kind === "bool"))
+                return expr.value;
+        }
         // A union destination can accept the binding's tagged storage directly.
         // The checker's single-arm flow type can be stale after a callback writes
         // the binding. Extracting that arm and wrapping it again would discard the
@@ -8717,6 +9382,40 @@ export class Lowerer {
         }
         return this.coerceInto(node, value, expected);
     }
+    /** The right side of a write to a member of a typed view of the global
+     * object (`(globalThis as typeof globalThis & { k?: T }).k = value`, also
+     * through `??=` and `||=`) that is `value` itself or wraps only it in
+     * parentheses or `satisfies`; null when `value` is not in such a write. */
+    globalViewSlot(value) {
+        let operand = value;
+        while (operand.parent !== undefined &&
+            (ts.isParenthesizedExpression(operand.parent) || ts.isSatisfiesExpression(operand.parent)))
+            operand = operand.parent;
+        const write = operand.parent;
+        if (write === undefined ||
+            !ts.isBinaryExpression(write) ||
+            write.right !== operand ||
+            (write.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
+                write.operatorToken.kind !== ts.SyntaxKind.QuestionQuestionEqualsToken &&
+                write.operatorToken.kind !== ts.SyntaxKind.BarBarEqualsToken))
+            return null;
+        let target = write.left;
+        while (ts.isParenthesizedExpression(target))
+            target = target.expression;
+        if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target))
+            return null;
+        const receiver = this.typeOf(target.expression);
+        const isGlobal = (type) => {
+            const symbol = type.getSymbol();
+            return (symbol !== undefined &&
+                ts.symbolName(symbol) === "globalThis" &&
+                symbol.declarations.length === 0);
+        };
+        return isGlobal(receiver) ||
+            (receiver.isIntersectionType() && ts.constituentTypes(receiver).some(isGlobal))
+            ? operand
+            : null;
+    }
     /** Lower for a known destination, then apply ordinary value coercion.
      * Fresh arrays and records use the destination layout directly. */
     lowerExprExpecting(node, expected) {
@@ -8725,6 +9424,9 @@ export class Lowerer {
         // retain their own checked conversion and must not be erased here.
         while (ts.isParenthesizedExpression(node) || ts.isSatisfiesExpression(node))
             node = node.expression;
+        const staged = this.stagedArgument(node);
+        if (staged)
+            return expected ? this.coerceInto(node, staged, expected) : staged;
         if (expected) {
             if (ts.isConditionalExpression(node))
                 return lowerTernary(this, node, expected);
@@ -8781,6 +9483,20 @@ export class Lowerer {
             // belong to the array the program keeps, rather than a typed snapshot.
             if (ts.isArrayLiteralExpression(x) &&
                 x.elements.nodes.every((element) => !ts.isSpreadElement(element) && !ts.isOmittedExpression(element))) {
+                // A checked slot that the program declares as a native array (a
+                // member of a typed view of the global object, `typeof globalThis &
+                // { cache?: number[] }`) is read back through that declaration. Build
+                // the native array and store it boxed: every typed read then extracts
+                // that same array (a dynamic literal would be copied on each read,
+                // losing writes such as push).
+                const slot = this.globalViewSlot(x);
+                const slotType = slot ? this.checker.getContextualType(slot) : undefined;
+                const declared = slotType && this.checker.getNonNullableType(slotType);
+                const native = declared && !(declared.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))
+                    ? this.mapTypeOf(declared)
+                    : null;
+                if (native?.kind === "array")
+                    return this.coerceInto(node, this.lowerArrayLiteral(x, native), DYN);
                 return {
                     kind: "dynArrLit",
                     elems: x.elements.nodes.map((element) => this.lowerExprExpecting(element, DYN)),
@@ -8807,7 +9523,9 @@ export class Lowerer {
                     builtinOption("UrlObject") ||
                     builtinOption("URLFormatOptions") ||
                     !this.mapTypeOf(this.typeOf(x)) ||
-                    this.excessJsContextualProperty(x, parts)) {
+                    this.excessJsContextualProperty(x, parts) ||
+                    this.reshapeableContextualLiteral(x, parts) ||
+                    holdsEvolvingArray(this, x)) {
                     return lowerDynObjectLiteral(this, x);
                 }
             }
@@ -8986,8 +9704,27 @@ export class Lowerer {
         // must not force an intermediate record with incompatible field slots.
         if (this.returnsLiteralIntoDyn(node, expected))
             return this.lowerExprExpecting(node, expected);
+        if (this.returnsFreshCollection(node) && expected.kind !== "void")
+            return this.lowerExprExpecting(node, expected);
         return this.asyncReturnValueOf(node, this.lowerExpr(node), expected);
     }
+    /** 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
+     * layout the way a synchronous return does (`return []` in a function
+     * whose inferred result is `Promise<string[]>`). */
+    returnsFreshCollection(node) {
+        let e = node;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (ts.isArrayLiteralExpression(e))
+            return true;
+        return (ts.isNewExpression(e) &&
+            ts.isIdentifier(e.expression) &&
+            (this.isStdlibGlobal(e.expression, "Map") ||
+                this.isStdlibGlobal(e.expression, "Set") ||
+                this.isStdlibGlobal(e.expression, "Array")));
+    }
     /** A fresh JS object literal returned into a checked-native (dyn) result,
      * which lowers straight into that storage. */
     returnsLiteralIntoDyn(node, expected) {
@@ -9113,7 +9850,9 @@ export class Lowerer {
                 loc,
             };
         }
-        if (this.adoptsReturnedPromise() && !this.returnsLiteralIntoDyn(node, expected)) {
+        if (this.adoptsReturnedPromise() &&
+            !this.returnsLiteralIntoDyn(node, expected) &&
+            !this.returnsFreshCollection(node)) {
             // 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.
@@ -9499,8 +10238,8 @@ export class Lowerer {
             throw e;
         }
     }
-    lowerClassExpression(expr) {
-        return lowerClassExpression(this, expr);
+    lowerClassExpression(expr, binding) {
+        return lowerClassExpression(this, expr, binding);
     }
     /* ── the class graph (single inheritance) ─────────────────────────── */
     findMethodOn(info, name) {
@@ -10453,10 +11192,23 @@ export class Lowerer {
     }
     /* ── expressions ──────────────────────────────────────────────────── */
     lowerExpr(expr) {
-        const hash = this.hashStreamReceivers.get(expr);
-        if (hash)
-            return hashStreamOf(varRef(hash.localId, hash.type, locOf(expr)));
-        return lowerExpr(this, expr);
+        const streamValue = this.valueStreamReceivers.get(expr);
+        if (streamValue)
+            return valueStreamOf(varRef(streamValue.localId, streamValue.type, locOf(expr)));
+        return this.stagedArgument(expr) ?? lowerExpr(this, expr);
+    }
+    /** The saved value of a staged fs argument (stagedArguments, keyed
+     * without type-only wrappers), or null for every other expression. */
+    stagedArgument(node) {
+        if (this.stagedArguments.size === 0)
+            return null;
+        node = stripTypeWrappers(node);
+        if (!this.stagedArguments.has(node))
+            return null;
+        const slot = this.stagedArguments.get(node);
+        if (!slot)
+            throw new InternalCompilerError("an fs argument lowered before the URL path it follows");
+        return varRef(slot.localId, slot.type, locOf(node));
     }
     lowerIntrinsicProperty(expr) {
         // The builtin-spoke property extensions (Stats.mtimeMs,
@@ -10586,7 +11338,7 @@ export class Lowerer {
         return lowerRecordKeyRead(this, expr, shapeId, shape, includeUndefined);
     }
     lowerElementWrite(expr) {
-        return lowerElementWrite(this, expr);
+        return markSloppyRecordWrites(this, lowerElementWrite(this, expr), expr);
     }
     lowerLiveWebValue(node) {
         return lowerLiveWebValue(this, node);
@@ -10715,6 +11467,25 @@ export class Lowerer {
             return lower();
         return this.withExpressionOverride(node, this.checkedNarrowCall(helper, optional.value, optional.present, locOf(node)), lower);
     }
+    /** withExpressionOverride for several nodes at once. */
+    withExpressionOverrides(overrides, lower) {
+        const previous = overrides.map((override) => this.chainRecvByNode.get(override.node));
+        for (const override of overrides)
+            this.chainRecvByNode.set(override.node, override.value);
+        try {
+            return lower();
+        }
+        finally {
+            for (let i = overrides.length - 1; i >= 0; i--) {
+                const node = overrides[i].node;
+                const value = previous[i];
+                if (value)
+                    this.chainRecvByNode.set(node, value);
+                else
+                    this.chainRecvByNode.delete(node);
+            }
+        }
+    }
     withExpressionOverride(node, value, lower) {
         const previous = this.chainRecvByNode.get(node);
         this.chainRecvByNode.set(node, value);
@@ -10736,7 +11507,8 @@ export class Lowerer {
         if (webAssembly !== null)
             return webAssembly;
         refuseWebAssemblyUse(this, expr.expression);
-        return (lowerLifetimeRegionCall(this, expr) ??
+        return (lowerErrorFunctionCall(this, expr) ??
+            lowerLifetimeRegionCall(this, expr) ??
             lowerInternTableCall(this, expr) ??
             lowerThreadSlotsCall(this, expr) ??
             lowerFfiCall(this, expr) ??
@@ -10752,6 +11524,7 @@ export class Lowerer {
             lowerWebCryptoCall(this, expr) ??
             lowerKeyObjectCall(this, expr) ??
             lowerEcdhCall(this, expr) ??
+            lowerDiffieHellmanCall(this, expr) ??
             lowerNetAddressCall(this, expr) ??
             lowerFetchElementMethodCall(this, expr) ??
             lowerDynamicImportCall(this, expr) ??
@@ -10864,7 +11637,7 @@ export class Lowerer {
             : null;
     }
     fieldSetStmt(target, value, loc, blame) {
-        return fieldSetStmt(this, target, value, loc, blame);
+        return markSloppyRecordWrites(this, fieldSetStmt(this, target, value, loc, blame), blame);
     }
     lowerFieldCompound(access, op, rhsNode, loc) {
         return lowerFieldCompound(this, access, op, rhsNode, loc);
@@ -10894,6 +11667,7 @@ export class Lowerer {
             lowerBlobNew(this, expr) ??
             lowerNetAddressNew(this, expr) ??
             lowerStaticReadableStreamNew(this, expr) ??
+            lowerStaticTransformStreamNew(this, expr) ??
             lowerConsoleNew(this, expr);
         return (builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr)));
     }
@@ -11259,6 +12033,10 @@ export class Lowerer {
             if (callable)
                 return callable;
         }
+        // node:crypto's webcrypto is the WebCrypto global's object.
+        if (bi.module === "crypto" && bi.member === "webcrypto") {
+            return { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc };
+        }
         // node:stream/web's exports are the web stream globals themselves: in
         // JavaScript sources the same identity token as the global spelling
         // (`require("stream/web").ReadableStream === globalThis.ReadableStream`).
@@ -11328,7 +12106,7 @@ export class Lowerer {
         const key = `${fn.valueFn ?? fn.fn}:${typeKey(funcType)}:${adapterShape}`;
         let fnName = this.builtinCallableValueFns.get(key);
         if (!fnName) {
-            fnName = `%builtin.value.${fn.valueFn ?? fn.fn}.${this.builtinCallableValueFns.size}`;
+            fnName = keyedHelperName(this, `%builtin.value.${fn.valueFn ?? fn.fn}`, key);
             this.builtinCallableValueFns.set(key, fnName);
             this.builtinCallableValueNames.set(fnName, display.slice(display.lastIndexOf(".") + 1));
             const params = funcType.params.map((type, index) => ({