@scriptc/compiler 0.4.1 → 0.4.2

package/dist/frontend/lowering/lowerer.js

@@ -1,4 +1,7 @@
-import { onlyForwarded } from "./typed-arguments.js";
+import { relieveHeapPressure } from "../../heap-pressure.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 +17,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,8 +33,9 @@ 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";
@@ -49,6 +55,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";
@@ -66,6 +73,7 @@ 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,7 +95,7 @@ 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 * as ts from "../ts7/adapter.js";
@@ -147,7 +155,8 @@ import { lowerStringDecoderMethodCall, lowerTextCodecCall } from "./builtins/tex
 import { lowerReadlineMethodCall } from "./builtins/readline.js";
 import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, lowerAsyncLocalStorageMethodCall, lowerTracingChannelMethodCall, lowerTracingChannelProperty, } from "./builtins/async-context.js";
 import { lowerDisposableStackNew } from "./builtins/disposable-stack.js";
-import { lowerErrorCodeProperty } from "./builtins/errors.js";
+import { 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";
@@ -247,6 +256,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 +300,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 +493,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 +546,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 });
@@ -1061,6 +1119,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 +1153,9 @@ 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-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     neverReassignedCache = new Map();
@@ -1242,6 +1307,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 = [];
@@ -1323,6 +1417,12 @@ export class Lowerer {
     /** 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
@@ -1857,6 +1957,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 +2020,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 +2136,16 @@ 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();
+    /** Whether the program reads `Error.prototype`, the checked-dynamic
+     * object an ES5 constructor function can inherit from: only then can a
+     * value that is not an Error instance be `instanceof Error`. */
+    errorPrototypeValues = false;
     /** 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 +2210,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();
@@ -2210,6 +2334,10 @@ export class Lowerer {
     // top level, top = the innermost nested function currently lowering).
     fnStack = [];
     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 +2345,49 @@ export class Lowerer {
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision = null;
     errorPropertyDispatchRevision = null;
-    lambdaCounter = 0;
+    /** 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, and default library
+     * files by their base name: two checkers install them in different
+     * directories. */
+    positions = new StructuralPositions((sf) => this.program.isSourceFileDefaultLibrary(sf)
+        ? `lib:${sf.fileName.slice(sf.fileName.lastIndexOf("/") + 1)}`
+        : 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 ? `${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 +2439,10 @@ 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;
     /** 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 +2456,136 @@ 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]));
+        const earlier = (left, right) => left.file < right.file || (left.file === right.file && left.start < right.start);
+        // 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;
@@ -2435,6 +2739,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 +2748,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,
@@ -2561,16 +2869,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 +2978,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 +4068,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 +4245,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);
@@ -4241,8 +4557,11 @@ export class Lowerer {
                 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 +5066,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 +5309,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 +5425,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 +5503,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.
@@ -5461,6 +5789,7 @@ export class Lowerer {
                                 if (promoteHofCallback(callback, [0, 1]))
                                     changed = true;
                                 const result = this.runtimeOptionalType(this.irTypeOf(node));
+                                siteDependencies?.read(node);
                                 const previous = this.runtimeOptionalReduceTypes.get(node);
                                 if (!previous || !typeEquals(previous, result)) {
                                     this.runtimeOptionalReduceTypes.set(node, result);
@@ -5518,6 +5847,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 +5887,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 +5939,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 +5964,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 +5991,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 +6058,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 +6085,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 +6135,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 +6151,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 +6176,7 @@ export class Lowerer {
                     : this.runtimeOptionalType(previous);
                 if (!typeEquals(previous, next)) {
                     this.runtimeOptionalFunctionReturns.set(fn, next);
+                    siteDependencies.changed(fn);
                     changed = true;
                 }
             }
@@ -5822,6 +6191,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 +6208,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])
@@ -6195,7 +6569,7 @@ export class Lowerer {
             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 +6582,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 +6623,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 +6635,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 +6654,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));
@@ -6409,7 +6786,7 @@ 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 } : {}),
@@ -6538,6 +6915,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 +7171,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 +7191,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 +7205,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 +7246,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 +7254,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 +7269,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 +7288,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 +7319,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 +7331,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 +7733,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 +8037,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;
@@ -8453,6 +8893,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
@@ -8725,6 +9178,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);
@@ -10453,10 +10909,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,
@@ -10715,6 +11184,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 +11224,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 +11241,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) ??
@@ -11259,6 +11749,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 +11822,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) => ({