@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/lowering/lower-modules.js

@@ -8,52 +8,89 @@ import { InternalCompilerError } from "../../errors.js";
  * seeds), npm/JSON import collection, per-file %init functions, %main, and
  * the module artifacts (globals, embedded npm tables) the IR module carries. */
 import * as ts from "../ts7/adapter.js";
+import { collectRebindableFunctions, isRebindableFunction } from "./rebindable-functions.js";
 import { bindingSource } from "../binding-source.js";
 import { dirname as dirnamePath, resolve as resolvePath } from "node:path";
 import { packageNameOfPath, probeNodeImportRefusal } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
 import { isJsSourceFileName } from "../tsc-codes.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
-import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, resolveImport, resolveNpmImport, } from "../program.js";
+import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, requireSpecOf, resolveImport, resolveNpmImport, } from "../program.js";
 import { markCycleEarlyBindings, withClassInitFlag, withCycleInitFlags, } from "./cycle-initialization.js";
+import { markRequireEarlyBindings } from "./require-initialization.js";
+import { cjsTableMethodEntry, inlineProgramRequireOf, nestedCjsExportAssignmentsOf, requireNestedPatternsOf, } from "./cjs-inline-require.js";
+import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
+import { collectJsonRequires, isJsonRequireDecl } from "./json-require.js";
 import { invalidJsonModuleDiag, unsupportedPackageImportDiag, } from "../../diagnostics/diagnostic.js";
 import { BOOL, CAUGHT, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, isUnitType, } from "../../ir/ir.js";
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, newFnCtx, staticImportNamespaceType, } from "./lowerer.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, } from "./builtins/module-bindings.js";
 import { isPromisifyCall, registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
+import { registerBuiltinClassAlias } from "./builtins/class-values.js";
 import { stripTypeCasts } from "./builtins/arguments.js";
+import { isWebCryptoMemberType } from "./builtins/webcrypto.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, implicitLocalFnInfoOf, implicitLocalFnNodeOf, } from "./generic-functions.js";
 import { bindingNeverReassigned, deadUnmappableBinding, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
 import { funcTypeFromParamShapes, registerOverloadedCallableAlias } from "./call-signatures.js";
-import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl, } from "./lower-stmts.js";
+import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl, stdlibBufferVarAlias, } from "./lower-stmts.js";
 import { objectFactoryGlobalType } from "./object-factory-new.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
 import { isAssertClassNew } from "./assert-instances.js";
 import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
+import { isPromisePrototypeRead } from "./expressions/property-access.js";
 import { collectNamespaceStmt, nsMemberIdentOf, nsPathPrefix, trapDeclRootOf, } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
-import { collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType, } from "./lower-classes.js";
+import { builtinRequireBaseOf, collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType, } from "./lower-classes.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js";
 import { forkTargetPaths } from "../fork-target.js";
 import { workerTargetPaths } from "../worker-target.js";
 import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 import { handleEventReaderPrelude } from "./lower-event-target.js";
+import { cjsAccessorSnapshotStores, jsHoldsDynObject } from "./lower-exprs.js";
+import { keptIdentityAssertion } from "./assertion-identity.js";
+/** An appended module's edges: its import and export declarations, then
+ * the require() edges preflight resolved — a CommonJS file's only edges
+ * (the compiled CommonJS package a workspace module loaded on demand
+ * imports, and the sibling packages and files IT requires). */
+function appendedEdgesOf(program, graph) {
+    const cache = new Map();
+    return (sf) => {
+        let out = cache.get(sf);
+        if (out !== undefined)
+            return out;
+        out = orderedImportsOf(program, sf).flatMap(({ stmt, dep }) => dep !== null && dep !== sf
+            ? [{ dep, stmt: stmt }]
+            : []);
+        for (const e of graph?.edges?.get(sf) ?? [])
+            if (e.stmt === undefined && e.dep !== sf)
+                out.push(e);
+        cache.set(sf, out);
+        return out;
+    };
+}
+/** Lazy inline requires run after their module's top level: their modules
+ * join the order afterwards, as in preflight's walk. */
+function visitLazyEdges(sf, edgesOf, state, visit) {
+    for (const e of edgesOf(sf))
+        if (e.lazy === true && state.get(e.dep) === undefined)
+            visit(e.dep);
+}
 /** Program modules selected by statically resolved child_process.fork()
  * calls join the compiled graph without becoming startup dependencies of
  * the parent entry. Their guarded init functions are selected by %main only
  * in a re-executed fork child. `targets` is append-only so ids stay stable
  * across the dynamic-import/fork discovery fixpoint. */
-export function appendForkModules(program, order, targets, onCycle) {
-    appendEntryModules(program, order, targets, forkTargetPaths(program, order), onCycle);
+export function appendForkModules(program, order, targets, onCycle, graph) {
+    appendEntryModules(program, order, targets, forkTargetPaths(program, order), onCycle, graph);
 }
-export function appendWorkerModules(program, order, targets, onCycle) {
-    appendEntryModules(program, order, targets, workerTargetPaths(program, order), onCycle);
+export function appendWorkerModules(program, order, targets, onCycle, graph) {
+    appendEntryModules(program, order, targets, workerTargetPaths(program, order), onCycle, graph);
 }
-function appendEntryModules(program, order, targets, paths, onCycle) {
+function appendEntryModules(program, order, targets, paths, onCycle, graph) {
     if (order.length === 0)
         return;
     const byPath = new Map(program.getImplementationSourceFiles().map((sf) => [resolvePath(sf.fileName), sf]));
@@ -62,10 +99,8 @@ function appendEntryModules(program, order, targets, paths, onCycle) {
         state.set(sf, "done");
     const added = [];
     const stack = [];
-    const staticEdgesOf = (sf) => orderedImportsOf(program, sf).flatMap(({ stmt, dep }) => dep !== null && dep !== sf
-        ? [{ dep, stmt: stmt }]
-        : []);
-    const cycleAdmissionReason = makeCycleAdmission(program, staticEdgesOf);
+    const staticEdgesOf = appendedEdgesOf(program, graph);
+    const cycleAdmissionReason = makeCycleAdmission(program, (sf) => staticEdgesOf(sf).filter((e) => e.call === undefined));
     const visit = (sf) => {
         const prior = state.get(sf);
         if (prior === "done")
@@ -73,10 +108,16 @@ function appendEntryModules(program, order, targets, paths, onCycle) {
         state.set(sf, "visiting");
         stack.push(sf.fileName);
         for (const edge of staticEdgesOf(sf)) {
+            if (edge.lazy === true)
+                continue; // visited after this module completes
             const edgeState = state.get(edge.dep);
             if (edgeState === "done")
                 continue;
             if (edgeState === "visiting") {
+                if (edge.call !== undefined) {
+                    graph?.inlineCycleCalls?.add(edge.call);
+                    continue;
+                }
                 const reason = cycleAdmissionReason(sf, edge);
                 if (reason !== null) {
                     const cycleStart = stack.indexOf(edge.dep.fileName);
@@ -89,6 +130,7 @@ function appendEntryModules(program, order, targets, paths, onCycle) {
         stack.pop();
         state.set(sf, "done");
         added.push(sf);
+        visitLazyEdges(sf, staticEdgesOf, state, visit);
     };
     const knownTargets = new Set(targets);
     for (const path of paths) {
@@ -113,8 +155,13 @@ export function splitFiles(lowerer) {
     const files = lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry];
     return files.map((sf) => {
         const fp = { sf, fnDecls: [], classDecls: [], topStmts: [] };
-        for (const stmt of sf.statements) {
-            if (ts.isFunctionDeclaration(stmt))
+        const rebindable = collectRebindableFunctions(lowerer, sf);
+        for (const stmt of sf.statements.nodes) {
+            // A reassigned JavaScript declaration lives in a module global that
+            // the init body assigns first (rebindable-functions.ts).
+            if (ts.isFunctionDeclaration(stmt) && rebindable.has(stmt))
+                fp.topStmts.push(stmt);
+            else if (ts.isFunctionDeclaration(stmt))
                 fp.fnDecls.push(stmt);
             else if (ts.isClassDeclaration(stmt))
                 fp.classDecls.push(stmt);
@@ -162,9 +209,9 @@ function dynamicProgramImportsOf(program, sf) {
     ts.walkPreorder(sf, (node) => {
         if (ts.isCallExpression(node) &&
             node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-            node.arguments[0] !== undefined &&
-            ts.isStringLiteralLike(node.arguments[0])) {
-            const dep = dynamicImportProgramTargetOf(program, sf, node.arguments[0].text);
+            node.arguments.nodes[0] !== undefined &&
+            ts.isStringLiteralLike(node.arguments.nodes[0])) {
+            const dep = dynamicImportProgramTargetOf(program, sf, node.arguments.nodes[0].text);
             if (dep && !seen.has(dep)) {
                 seen.add(dep);
                 out.push(dep);
@@ -173,7 +220,7 @@ function dynamicProgramImportsOf(program, sf) {
     });
     return out;
 }
-export function appendDynamicImportModules(program, order, onCycle) {
+export function appendDynamicImportModules(program, order, onCycle, graph) {
     if (order.length === 0)
         return; // no preflight order — sites keep their fences
     const state = new Map();
@@ -181,20 +228,24 @@ export function appendDynamicImportModules(program, order, onCycle) {
         state.set(sf, "done");
     const added = [];
     const stack = [];
-    const staticEdgesOf = (sf) => orderedImportsOf(program, sf).flatMap(({ stmt, dep }) => dep !== null && dep !== sf
-        ? [{ dep, stmt: stmt }]
-        : []);
-    const cycleAdmissionReason = makeCycleAdmission(program, staticEdgesOf);
+    const staticEdgesOf = appendedEdgesOf(program, graph);
+    const cycleAdmissionReason = makeCycleAdmission(program, (sf) => staticEdgesOf(sf).filter((e) => e.call === undefined));
     const visit = (sf) => {
         if (state.get(sf) !== undefined)
             return;
         state.set(sf, "visiting");
         stack.push(sf.fileName);
         for (const e of staticEdgesOf(sf)) {
+            if (e.lazy === true)
+                continue; // visited after this module completes
             const s = state.get(e.dep);
             if (s === "done")
                 continue;
             if (s === "visiting") {
+                if (e.call !== undefined) {
+                    graph?.inlineCycleCalls?.add(e.call);
+                    continue;
+                }
                 // A back edge: Node answers it from the cache. Same admission
                 // question as preflight's static walk, same fence when refused.
                 const reason = cycleAdmissionReason(sf, e);
@@ -209,6 +260,7 @@ export function appendDynamicImportModules(program, order, onCycle) {
         stack.pop();
         state.set(sf, "done");
         added.push(sf);
+        visitLazyEdges(sf, staticEdgesOf, state, visit);
     };
     const scanned = new Set();
     for (;;) {
@@ -233,8 +285,8 @@ export function collectProgram(lowerer, parts) {
     const computed = new Set();
     for (const fp of parts)
         for (const decl of fp.classDecls) {
-            const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
-            if (heritage && ts.isCallExpression(heritage))
+            const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
+            if (heritage && ts.isCallExpression(heritage) && !builtinRequireBaseOf(lowerer, heritage))
                 computed.add(decl);
         }
     // Descendants need the computed ancestor's completed layout before
@@ -249,7 +301,7 @@ export function collectProgram(lowerer, parts) {
             for (const decl of fp.classDecls) {
                 if (computed.has(decl))
                     continue;
-                const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+                const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
                 const base = heritage && ts.isIdentifier(heritage) ? lowerer.resolveValueSymbol(heritage) : undefined;
                 if (!base || !computedSymbols.has(base))
                     continue;
@@ -286,6 +338,7 @@ export function collectProgram(lowerer, parts) {
                 lowerer.collectGlobals(fp.sf, fp.topStmts);
             lowerer.collectNpmImports(parts);
             lowerer.collectJsonImports(parts);
+            collectJsonRequires(lowerer, parts);
         }
         finally {
             lowerer.diagSink = null;
@@ -296,6 +349,7 @@ export function collectProgram(lowerer, parts) {
             lowerer.collectGlobals(fp.sf, fp.topStmts);
         lowerer.collectNpmImports(parts);
         lowerer.collectJsonImports(parts);
+        collectJsonRequires(lowerer, parts);
     }
     for (const decl of computed) {
         const symbol = declSymbolOf(lowerer, decl);
@@ -304,7 +358,7 @@ export function collectProgram(lowerer, parts) {
         const previousSink = lowerer.diagSink;
         const deferred = [];
         lowerer.diagSink = deferred;
-        const expression = decl.heritageClauses.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword).types[0].expression;
+        const expression = decl.heritageClauses.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword).types.nodes[0].expression;
         const context = newFnCtx(false, null, null, DYN);
         lowerer.fnStack.push(context);
         try {
@@ -376,11 +430,12 @@ export function collectProgram(lowerer, parts) {
         lowerer.collecting = wasCollecting;
     }
     markCycleEarlyBindings(lowerer);
+    markRequireEarlyBindings(lowerer);
 }
 export function collectNpmImports(lowerer, parts) {
     const entryPackageFile = entryPackageFilePredicate(lowerer.entry.fileName);
     for (const fp of parts) {
-        for (const stmt of fp.sf.statements) {
+        for (const stmt of fp.sf.statements.nodes) {
             // NAMED re-exports from npm packages (`export { isUrl } from
             // "url-or-path"`): use the same package bindings as direct imports.
             const reexport = ts.isExportDeclaration(stmt) &&
@@ -389,7 +444,7 @@ export function collectNpmImports(lowerer, parts) {
                 ts.isStringLiteral(stmt.moduleSpecifier) &&
                 stmt.exportClause !== undefined &&
                 ts.isNamedExports(stmt.exportClause) &&
-                stmt.exportClause.elements.some((e) => !e.isTypeOnly) &&
+                stmt.exportClause.elements.nodes.some((e) => !e.isTypeOnly) &&
                 !stmt.moduleSpecifier.text.startsWith("#")
                 ? stmt.exportClause
                 : null;
@@ -407,7 +462,7 @@ export function collectNpmImports(lowerer, parts) {
             if (clause?.namedBindings &&
                 ts.isNamedImports(clause.namedBindings) &&
                 !clause.name &&
-                clause.namedBindings.elements.every((e) => e.isTypeOnly)) {
+                clause.namedBindings.elements.nodes.every((e) => e.isTypeOnly)) {
                 continue;
             }
             const spec = specNode.text;
@@ -492,10 +547,10 @@ function collectDynamicImports(lowerer, sf) {
     ts.walkPreorder(sf, (node) => {
         if (ts.isCallExpression(node) &&
             node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-            node.arguments.length >= 1 &&
-            node.arguments[0] !== undefined &&
-            ts.isStringLiteralLike(node.arguments[0])) {
-            const spec = node.arguments[0].text;
+            node.arguments.nodes.length >= 1 &&
+            node.arguments.nodes[0] !== undefined &&
+            ts.isStringLiteralLike(node.arguments.nodes[0])) {
+            const spec = node.arguments.nodes[0].text;
             if (lowerer.externalTypes.has(spec)) {
                 return undefined;
             }
@@ -506,11 +561,9 @@ function collectDynamicImports(lowerer, sf) {
                 // module has no runtime namespace object — the per-site fence
                 // says so. Only non-declaration source files count; a sibling
                 // .d.mts typing shipped JS is the EMBED case, not this one.
-                const modSym = lowerer.checker.getSymbolAtLocation(node.arguments[0]);
+                const modSym = lowerer.checker.getSymbolAtLocation(node.arguments.nodes[0]);
                 const ownModule = modSym !== undefined &&
-                    lowerer.checker
-                        .declarationsOf(modSym)
-                        .some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
+                    modSym.declarations.some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
                 const builtin = canonicalBuiltinModule(spec);
                 const res = ownModule
                     ? { kind: "program-module" }
@@ -540,7 +593,7 @@ function collectDynamicImports(lowerer, sf) {
  * and kept .json files out of the module order. */
 export function collectJsonImports(lowerer, parts) {
     for (const fp of parts) {
-        for (const stmt of fp.sf.statements) {
+        for (const stmt of fp.sf.statements.nodes) {
             if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
                 continue;
             const clause = stmt.importClause;
@@ -550,7 +603,9 @@ export function collectJsonImports(lowerer, parts) {
             if (!nameSym || !(nameSym.flags & ts.SymbolFlags.Alias))
                 continue;
             const target = lowerer.checker.getAliasedSymbol(nameSym);
-            const jsonSf = lowerer.checker.declarationsOf(target)[0]?.getSourceFile();
+            const jsonSf = target.declarations.length === 0
+                ? undefined
+                : ts.getSourceFileOfNode(target.declarations[0]);
             if (!jsonSf || !jsonSf.fileName.endsWith(".json"))
                 continue;
             try {
@@ -728,6 +783,14 @@ export function moduleArtifacts(lowerer, functions) {
                         valueInstanceOfRoots.add(root.def.name);
                     }
                     break;
+                case "libCall":
+                    // The general stream representation's child stdio read bridges
+                    // through the runtime install that boxes both stream classes.
+                    if (node.fn === "child.stdioStream") {
+                        visitClass("%Readable");
+                        visitClass("%Writable");
+                    }
+                    break;
                 case "dynFrom":
                     if (boxedChild(node.value.type)) {
                         // A generic child can expose native stdio without importing stream.
@@ -919,7 +982,7 @@ function checkedGlobalReference(lowerer, expression) {
         !ts.isIdentifier(expression.expression))
         return false;
     const root = lowerer.checker.getSymbolAtLocation(expression.expression);
-    const namespace = root && lowerer.checker.declarationsOf(root).some(ts.isNamespaceImport);
+    const namespace = root && root.declarations.some(ts.isNamespaceImport);
     return ((namespace || lowerer.cjsLocalModuleBindingOf(expression.expression)) &&
         lowerer.globalOf(expression.name)?.type.kind === "dyn");
 }
@@ -937,8 +1000,8 @@ function jsDynHoldableInitializer(lowerer, init) {
         ts.isPropertyAccessExpression(e.expression) &&
         ["freeze", "seal", "preventExtensions"].includes(e.expression.name.text) &&
         lowerer.stdlibGlobalMember(e.expression, "Object") !== null &&
-        e.arguments[0] &&
-        ts.isArrayLiteralExpression(e.arguments[0]))
+        e.arguments.nodes[0] &&
+        ts.isArrayLiteralExpression(e.arguments.nodes[0]))
         return true;
     // The built-in Array constructor can create an evolving array whose
     // inferred element type has no native mapping. Its checked reference
@@ -1001,8 +1064,8 @@ function jsDynHoldableInitializer(lowerer, init) {
             return true;
     }
     if ((ts.isFunctionExpression(e) || ts.isArrowFunction(e)) &&
-        !e.typeParameters?.length &&
-        isJsSourceFile(e.getSourceFile()))
+        !e.typeParameters?.nodes.length &&
+        isJsSourceFile(ts.getSourceFileOfNode(e)))
         return true;
     if (ts.isIdentifier(e) || ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
         if (ts.isIdentifier(e)) {
@@ -1037,6 +1100,30 @@ function jsDynHoldableInitializer(lowerer, init) {
     }
     return false;
 }
+/** A JavaScript default-export object literal holding a class the program
+ * could not lower (`export default { parse, TomlDate }` where TomlDate
+ * extends an unsupported base): the literal narrows that member away, its
+ * diagnostics deferred to the reads that reach it, so the binding's type
+ * drops it too. Otherwise the module's own initialization would fail the
+ * width check against members no build can supply. */
+function withoutRejectedClassMembers(lowerer, expression, type) {
+    let literal = expression;
+    while (ts.isParenthesizedExpression(literal))
+        literal = literal.expression;
+    if (!ts.isObjectLiteralExpression(literal) || type.kind !== "record")
+        return type;
+    const shape = lowerer.shapes.get(type.shapeId);
+    if (!shape || shape.tuple)
+        return type;
+    const rejected = (t) => t.kind === "classval" &&
+        !lowerer.classes.has(t.className) &&
+        lowerer.deferredClassByName.has(t.className);
+    if (!shape.fields.some((f) => rejected(f.type)))
+        return type;
+    const kept = shape.fields.filter((f) => !rejected(f.type));
+    const shapeId = lowerer.shapes.intern(kept.map((f) => ({ name: f.name, type: f.type })), false, shape.indexValue);
+    return { kind: "record", shapeId };
+}
 export function collectGlobals(lowerer, sf, topStmts) {
     // Segment-tagged so mangled names can't collide across files (user
     // identifiers cannot contain '.'): entry globals "e.<name>", others
@@ -1048,6 +1135,21 @@ export function collectGlobals(lowerer, sf, topStmts) {
     // collected earlier in this pass must resolve them (lower-expando.ts).
     collectExpandoMembers(lowerer, sf);
     for (const stmt of topStmts) {
+        if (ts.isFunctionDeclaration(stmt) && stmt.name && isRebindableFunction(lowerer, stmt)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(stmt.name);
+            if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                const g = {
+                    id: `%g.${tag}${stmt.name.text}`,
+                    name: stmt.name.text,
+                    type: DYN,
+                    mutable: true,
+                };
+                lowerer.globalsBySymbol.set(symbol, g);
+                lowerer.globalsByDeclNode.set(stmt, g);
+                lowerer.globalsList.push(g);
+            }
+            continue;
+        }
         // `export default <expr>`: the module's `default` binding is a const
         // module global (registered under the checker's default-export
         // symbol — the symbol a default IMPORT's alias chain terminates at,
@@ -1078,10 +1180,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 continue;
             if (symbol.flags & ts.SymbolFlags.Alias) {
                 const target = lowerer.checker.getAliasedSymbol(symbol);
-                const vd = lowerer.checker.valueDeclarationOf(target);
+                const vd = target.valueDeclaration;
                 const mutableVar = vd !== undefined &&
                     ts.isVariableDeclaration(vd) &&
-                    !vd.getSourceFile().isDeclarationFile &&
+                    !ts.getSourceFileOfNode(vd).isDeclarationFile &&
                     (ts.getCombinedNodeFlags(vd) & ts.NodeFlags.Const) === 0;
                 // Immutable targets: alias plumbing — importers resolve to the
                 // target's storage (the alias-resolved read IS the snapshot when
@@ -1104,7 +1206,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     !isJsSourceFile(sf) &&
                     inner.typeParameters === undefined &&
                     (decoratorNodesOf(inner).length > 0 ||
-                        inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
+                        inner.members.nodes.some((m) => decoratorNodesOf(m).length > 0)) &&
                     guaranteedDecorationThrow(lowerer, inner) !== null) {
                     continue;
                 }
@@ -1136,6 +1238,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 }
                 if (type.kind === "void")
                     lowerer.badType(stmt.expression, tsType);
+                if (isJsSourceFile(sf))
+                    type = withoutRejectedClassMembers(lowerer, stmt.expression, type);
                 const g = { id: `%g.${tag}default`, name: "default", type, mutable: false };
                 lowerer.globalsBySymbol.set(symbol, g);
                 lowerer.globalsList.push(g);
@@ -1175,9 +1279,19 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // common/tls's `exports.check = function (certs) {...}` —
                     // keep func-ness with dyn pieces; everything else is dyn).
                     const strict = lowerer.checker.getTypeOfSymbol(symbol);
-                    const t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict);
+                    let t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict);
                     if (!t || t.kind === "void")
                         lowerer.badType(typeNode, strict);
+                    // An export typed as the empty object literal (tsc's enum output
+                    // `exports.E || (exports.E = {})` after its `exports.E = void 0`
+                    // preamble): TS's `{}` admits any later non-nullish value and the
+                    // export is undefined until then, so it rides checked-dynamic
+                    // storage like the same-shaped var binding (varBindingType).
+                    if (t.kind === "record" && isJsSourceFile(sf)) {
+                        const shape = lowerer.shapes.get(t.shapeId);
+                        if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
+                            t = DYN;
+                    }
                     // An immutable export source shares its live storage and native
                     // callable ABI. Mutable sources need a separate snapshot slot:
                     // later writes to the binding do not change the exported value.
@@ -1191,7 +1305,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                             if (vG) {
                                 if (!vG.mutable) {
                                     lowerer.globalsBySymbol.set(symbol, vG);
-                                    for (const d of lowerer.checker.declarationsOf(symbol))
+                                    for (const d of symbol.declarations)
                                         lowerer.globalsByDeclNode.set(d, vG);
                                     return;
                                 }
@@ -1202,7 +1316,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                                     mutable: false,
                                 };
                                 lowerer.globalsBySymbol.set(symbol, g);
-                                for (const d of lowerer.checker.declarationsOf(symbol))
+                                for (const d of symbol.declarations)
                                     lowerer.globalsByDeclNode.set(d, g);
                                 lowerer.globalsList.push(g);
                                 return;
@@ -1213,7 +1327,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     lowerer.globalsBySymbol.set(symbol, g);
                     // Importer aliases resolve to a DISTINCT late-bound symbol with
                     // the same declaration — key the node too (globalOf's fallback).
-                    for (const d of lowerer.checker.declarationsOf(symbol))
+                    for (const d of symbol.declarations)
                         lowerer.globalsByDeclNode.set(d, g);
                     lowerer.globalsList.push(g);
                 }
@@ -1225,6 +1339,11 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     deferJsCollectionDiags(lowerer, sf, diagsBefore);
                 }
             };
+            // Export members assigned in VALUE position at the module's top
+            // level (`const src = exports.src = []`) are exports too.
+            for (const nested of nestedCjsExportAssignmentsOf(stmt, cjs?.expr)) {
+                registerExport(nested.name, nested.name.text, nested.value);
+            }
             if (cjs?.kind === "member" && ts.isIdentifier(cjs.name)) {
                 // `exports.C = C` naming a CLASS declaration: alias plumbing —
                 // no storage (a class VALUE global would fence for
@@ -1233,6 +1352,20 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 // applies unchanged.
                 if (lowerer.cjsMemberExportClassSymbol(cjs.expr) !== null)
                     continue;
+                // A chain `exports.a = exports.b = value`: every member is an
+                // export holding the chain's one value.
+                const chain = cjsExportChainOf(cjs.expr);
+                if (chain !== null) {
+                    for (const nameNode of chain.names)
+                        registerExport(nameNode, nameNode.text, chain.value);
+                    continue;
+                }
+                // A dropped tsc void-init preamble whose real assignment is such a
+                // class alias registers nothing either: storage here would never
+                // be assigned, and importers would read it instead of the class.
+                const real = cjsVoidInitPreambleReals(cjs)?.get(cjs.name.text);
+                if (real && lowerer.cjsMemberExportClassSymbol(real.expr) !== null)
+                    continue;
                 registerExport(cjs.name, cjs.name.text, cjs.value);
                 continue;
             }
@@ -1265,7 +1398,19 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 // statement lowering evaluates the call exactly once at its
                 // source position and assigns that slot. Unmappable calls retain
                 // the existing statement-level fence.
-                const factoryValued = ts.isCallExpression(rhs);
+                // Any other computed value (`os.homedir || function () {…}`,
+                // `cond ? a : b`, `new Registry()`, `ns.member`) is the same single
+                // snapshot: Node stores whatever the expression produced. A
+                // require() of a program module is not: the exporter re-exports
+                // that module's exports, which requirers resolve through the
+                // checker's alias (the statement lowers to the dep's %init).
+                const factoryValued = !ts.isIdentifier(rhs) &&
+                    !ts.isClassExpression(rhs) &&
+                    !ts.isObjectLiteralExpression(rhs) &&
+                    !(requireSpecOf(rhs) !== null &&
+                        inlineProgramRequireOf(lowerer, rhs) !== null &&
+                        !sf.statements.nodes.some((s) => cjsExportAssignmentOf(s)?.kind === "member")) &&
+                    cjsExportTargetLiteral(rhs, sf) === null;
                 if (cjsScalarLiteral(rhs) || fnValued || factoryValued) {
                     const diagsBefore = lowerer.diags.length;
                     try {
@@ -1296,7 +1441,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 continue;
             }
             if (cjs?.kind === "table" && cjs.obj) {
-                for (const prop of cjs.obj.properties) {
+                for (const prop of cjs.obj.properties.nodes) {
                     if (ts.isShorthandPropertyAssignment(prop))
                         continue; // alias plumbing
                     if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.initializer))
@@ -1304,6 +1449,11 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
                         registerExport(prop.name, prop.name.text, prop.initializer);
                     }
+                    // A METHOD entry (`module.exports = { f(x) { … } }`) is an
+                    // expression-valued export whose value is the method's function.
+                    const method = cjsTableMethodEntry(prop);
+                    if (method !== null)
+                        registerExport(method.name, method.name.text, method.name);
                     // other property forms fence in the statement lowering
                 }
                 continue;
@@ -1328,10 +1478,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 lowerer.globalsBySymbol.has(aliasSym))
                 continue;
             const target = lowerer.checker.getAliasedSymbol(aliasSym);
-            const vd = lowerer.checker.valueDeclarationOf(target);
+            const vd = target.valueDeclaration;
             const mutableVar = vd !== undefined &&
                 ts.isVariableDeclaration(vd) &&
-                !vd.getSourceFile().isDeclarationFile &&
+                !ts.getSourceFileOfNode(vd).isDeclarationFile &&
                 (ts.getCombinedNodeFlags(vd) & ts.NodeFlags.Const) === 0;
             if (!mutableVar)
                 continue;
@@ -1344,7 +1494,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 if (type.kind === "void")
                     lowerer.badType(stmt.name, lowerer.typeOf(stmt.name));
                 const g = {
-                    id: `%g.${tag}${nsPathPrefix(stmt)}%alias.${stmt.name.text}%${stmt.getStart()}`,
+                    id: `%g.${tag}${nsPathPrefix(stmt)}%alias.${stmt.name.text}%${ts.tokenStartOfNode(stmt)}`,
                     name: stmt.name.text,
                     type,
                     mutable: false,
@@ -1369,6 +1519,14 @@ export function collectGlobals(lowerer, sf, topStmts) {
             collectNestedVarGlobals(lowerer, sf, stmt, tag);
             continue;
         }
+        // tsc's interop bindings and its then-dead helper declarations own no
+        // storage either (cjs-tsc-interop.ts).
+        if (isJsSourceFile(sf) &&
+            (isDeadTscHelperDecl(lowerer, stmt) ||
+                (stmt.declarationList.declarations.nodes.length === 1 &&
+                    tscInteropBindingOfDecl(lowerer, stmt.declarationList.declarations.nodes[0]) !== null))) {
+            continue;
+        }
         // CommonJS require declarations are alias plumbing (preflight owns
         // the module edges; resolveValueSymbol routes reads through to the
         // exporter's declarations): no storage, and the statement lowers to
@@ -1378,12 +1536,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
         // binding lower via the process surface.
         if (isRequireStatement(stmt) &&
             !(ts.isVariableStatement(stmt) &&
-                stmt.declarationList.declarations.some((decl) => isNativeFfiRequire(lowerer, decl.initializer)))) {
-            if (ts.isVariableStatement(stmt) && (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
-                for (const decl of stmt.declarationList.declarations) {
-                    stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer);
-                }
-            }
+                stmt.declarationList.declarations.nodes.some((decl) => isNativeFfiRequire(lowerer, decl.initializer) || isJsonRequireDecl(lowerer, decl)))) {
+            if (ts.isVariableStatement(stmt))
+                for (const decl of stmt.declarationList.declarations.nodes)
+                    registerRequireDeclBindings(lowerer, sf, stmt.declarationList, decl, tag);
             continue;
         }
         // `declare const __VERSION__: string` — AMBIENT: no storage exists
@@ -1391,7 +1547,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
         // exactly like running the source under Node). Reads lower to
         // Node's ReferenceError at the access (lower-exprs), and the
         // statement itself lowers to nothing.
-        if (ts.getCombinedModifierFlags(stmt.declarationList.declarations[0]) & ts.ModifierFlags.Ambient)
+        if (ts.getCombinedModifierFlags(stmt.declarationList.declarations.nodes[0]) &
+            ts.ModifierFlags.Ambient)
             continue;
         const list = stmt.declarationList;
         if ((list.flags & ts.NodeFlags.Using) !== 0)
@@ -1405,8 +1562,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
         // (`%g.e.A%B.x`), so `namespace A { export const x }` and a
         // top-level `const x` never collide; non-exported members add the
         // declaring block's position (block-local bindings).
-        const nsPrefix = nsPathPrefix(stmt, list.declarations[0]);
-        for (const decl of list.declarations) {
+        const nsPrefix = nsPathPrefix(stmt, list.declarations.nodes[0]);
+        for (const decl of list.declarations.nodes) {
             // --provenance-sources: an elided pure-annotated dead const in a
             // fetched source module registers no global (the statement
             // lowering emits nothing by the same test — see
@@ -1415,6 +1572,16 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // and put its fences on the build.
             if (provenanceElidedConstDecl(lowerer, decl))
                 continue;
+            // A require declarator beside other declarators (`var EventEmitter =
+            // require("events"), R = class extends EventEmitter {}`): the
+            // statement lowering treats it as the alias plumbing of a whole
+            // require statement (lowerVarDeclarator), so it owns no storage
+            // either. A global here would never be assigned, and a read through
+            // it would see null.
+            if (requireAliasDecl(lowerer, decl)) {
+                registerRequireDeclBindings(lowerer, sf, list, decl, tag);
+                continue;
+            }
             // A stored built-in numeric value iterator has no first-class
             // global representation. Its same-%init for-of uses are backed by
             // hidden source/cursor/done locals registered when the declaration
@@ -1532,6 +1699,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 continue;
             if (isConst && registerBuiltinCallableAlias(lowerer, decl.name, decl.initializer))
                 continue;
+            if (registerBuiltinClassAlias(lowerer, decl.name, decl.initializer))
+                continue;
             // `const f = (x) => ...` at file scope of an npm-static JS file
             // whose params are implicit-any: the implicit-monomorphization
             // twin of the generic binding above — no global exists; calls and
@@ -1644,6 +1813,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // stdlibGlobalAliasDecl; the statement lowering skips it by the
             // same test).
             const stableStdlibAlias = isConst ||
+                stdlibBufferVarAlias(lowerer, decl) ||
                 ((list.flags & ts.NodeFlags.Let) !== 0 &&
                     ts.isIdentifier(decl.name) &&
                     stdlibGlobalAliasNameOf(lowerer, decl.initializer) !== null &&
@@ -1667,7 +1837,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         decl.initializer &&
                         !decl.type &&
                         !hasJsTypeAnnotation(decl) &&
-                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode))) {
+                        (!lowerer.mapTypeOf(lowerer.typeOf(nameNode)) ||
+                            isWebCryptoMemberType(lowerer, lowerer.typeOf(nameNode)))) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = {
@@ -1688,18 +1859,48 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Builtin declarations do not always describe the concrete native
                     // callable ABI. Preserve checked-native values in shared storage;
                     // adapting the loader to (string) would replace its validation.
+                    // An inferred Promise.prototype binding holds an ordinary object
+                    // (isPromisePrototypeRead), in TypeScript as well.
                     const initializer = decl.initializer ? stripTypeCasts(decl.initializer) : undefined;
-                    if (isJsSourceFile(sf) &&
-                        nameNode === decl.name &&
-                        initializer &&
-                        (isNativeBuiltinValueInitializer(lowerer, initializer) ||
-                            (!decl.type &&
-                                !hasJsTypeAnnotation(decl) &&
-                                lowerer.mapTypeOf(lowerer.typeOf(nameNode))?.kind === "date") ||
-                            (!decl.type &&
-                                !hasJsTypeAnnotation(decl) &&
-                                checkedGlobalReference(lowerer, initializer)) ||
-                            stdlibGlobalNameOf(lowerer, initializer) === "globalThis")) {
+                    if ((nameNode === decl.name &&
+                        !decl.type &&
+                        isPromisePrototypeRead(lowerer, decl.initializer)) ||
+                        (isJsSourceFile(sf) &&
+                            nameNode === decl.name &&
+                            initializer &&
+                            (isNativeBuiltinValueInitializer(lowerer, initializer) ||
+                                (!decl.type &&
+                                    !hasJsTypeAnnotation(decl) &&
+                                    lowerer.mapTypeOf(lowerer.typeOf(nameNode))?.kind === "date") ||
+                                (!decl.type &&
+                                    !hasJsTypeAnnotation(decl) &&
+                                    checkedGlobalReference(lowerer, initializer)) ||
+                                stdlibGlobalNameOf(lowerer, initializer) === "globalThis"))) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                                ...(!isVarDeclared(decl) ? { tdz: true } : {}),
+                            };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                            if (isVarDeclared(decl))
+                                noteVarGlobalEntryInit(lowerer, sf, g);
+                        }
+                        continue;
+                    }
+                    // A file-scope binding of an assertion of the global object
+                    // (`const state = globalThis as { [KEY]?: State }`): the binding
+                    // holds that object, so writes through it reach the object other
+                    // modules read (assertion-identity.ts).
+                    const asserted = decl.initializer
+                        ? keptIdentityAssertion(lowerer, decl.initializer)
+                        : undefined;
+                    if (nameNode === decl.name && !decl.type && asserted) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = {
@@ -1755,7 +1956,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         nameNode === decl.name &&
                         decl.initializer &&
                         ts.isObjectLiteralExpression(decl.initializer) &&
-                        decl.initializer.properties.some((p) => !ts.isSpreadAssignment(p) &&
+                        decl.initializer.properties.nodes.some((p) => !ts.isSpreadAssignment(p) &&
                             (ts.isMethodDeclaration(p) ||
                                 ts.isAccessor(p) ||
                                 ts.isComputedPropertyName(p.name) ||
@@ -1798,7 +1999,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         nameNode === decl.name &&
                         decl.initializer !== undefined &&
                         ts.isObjectLiteralExpression(decl.initializer) &&
-                        decl.initializer.properties.every((p) => {
+                        decl.initializer.properties.nodes.every((p) => {
                             if (ts.isSpreadAssignment(p)) {
                                 return (ts.isIdentifier(p.expression) &&
                                     lowerer.globalOf(p.expression)?.type.kind === "dyn");
@@ -1824,6 +2025,35 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         }
                         continue;
                     }
+                    // A JS file-scope ARRAY LITERAL holding an existing checked-dynamic
+                    // object (a file-scope object literal binding above, directly or
+                    // in a nested literal): the literal builds as a checked-dynamic
+                    // array (lowerArrayLiteral), and the binding holds it, so the
+                    // element keeps its identity.
+                    if (isJsSourceFile(sf) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        decl.initializer !== undefined &&
+                        ts.isArrayLiteralExpression(decl.initializer) &&
+                        jsHoldsDynObject(lowerer, decl.initializer)) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                            if (isVarDeclared(decl))
+                                noteVarGlobalEntryInit(lowerer, sf, g);
+                        }
+                        continue;
+                    }
                     // A JS file-scope ANY-RESIDUE binding whose VALUE provably
                     // lives in the checked-dynamic tree: no initializer (`let catchWarning;` —
                     // test/common's warning ledger), a unit initializer (`let
@@ -1880,7 +2110,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                             : null;
                         const generic = member && lowerer.genericFnOf(member);
                         const fallback = (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) &&
-                            !initializer.typeParameters?.length
+                            !initializer.typeParameters?.nodes.length
                             ? lowerer.lambdaSignature(initializer).funcType
                             : member && lowerer.globalOf(member)?.type.kind === "dyn"
                                 ? DYN
@@ -1942,12 +2172,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         ts.isCallExpression(decl.initializer)
                         ? lowerer.checker.getResolvedSignature(decl.initializer)
                         : undefined;
-                    const callDeclaration = callSignature && lowerer.checker.signatureDeclaration(callSignature);
-                    const callType = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile())
+                    const callDeclaration = callSignature && callSignature.declaration;
+                    const callType = callDeclaration && isJsSourceFile(ts.getSourceFileOfNode(callDeclaration))
                         ? lowerer.mapTypeOf(lowerer.typeOf(nameNode))
                         : null;
                     const inferredJsCall = callDeclaration &&
-                        isJsSourceFile(callDeclaration.getSourceFile()) &&
+                        isJsSourceFile(ts.getSourceFileOfNode(callDeclaration)) &&
                         (!callType ||
                             (unannotatedCall &&
                                 callType.kind === "union" &&
@@ -1963,7 +2193,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         !hasJsTypeAnnotation(decl) &&
                         decl.initializer &&
                         (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) &&
-                        !decl.initializer.typeParameters?.length) {
+                        !decl.initializer.typeParameters?.nodes.length) {
                         type = lowerer.lambdaSignature(decl.initializer).funcType;
                     }
                     // Namespace aliases of inferred helpers carry the helper's
@@ -2023,7 +2253,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         ts.isCallExpression(decl.initializer) &&
                         ts.isPropertyAccessExpression(decl.initializer.expression) &&
                         lowerer.stdlibGlobalMember(decl.initializer.expression, "Object") === "assign" &&
-                        decl.initializer.arguments.some((arg) => ts.isIdentifier(arg) && lowerer.globalOf(arg)?.type.kind === "dyn")) {
+                        decl.initializer.arguments.nodes.some((arg) => ts.isIdentifier(arg) && lowerer.globalOf(arg)?.type.kind === "dyn")) {
                         type = DYN;
                     }
                     // Runtime-arity JavaScript callables can be returned by a
@@ -2169,6 +2399,11 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     };
                     lowerer.globalsBySymbol.set(symbol, g);
                     lowerer.globalsList.push(g);
+                    // `let f: T;` initializes the binding (to undefined) where the
+                    // declaration runs: later writes are ordinary stores, which the
+                    // pointer guard alone would refuse (markCycleEarlyBindings).
+                    if (g.tdz && !decl.initializer)
+                        lowerer.uninitializedLexicalGlobals.set(g.id, { name: nameNode, module: sf, symbol });
                     // Mutable checked-dynamic LET globals ride the same entry
                     // init: a closure called above the declaration statement
                     // reads the dyn undefined instead of faulting on NULL — the
@@ -2212,6 +2447,52 @@ function noteVarGlobalEntryInit(lowerer, sf, g) {
     inits.push(g);
     lowerer.varGlobalEntryInits.set(sf, inits);
 }
+/** A JavaScript require declaration the statement lowering treats as alias
+ * plumbing (lowerVarDeclarator): no storage, the reads resolve through to
+ * the module. JSON documents and native FFI requires keep their storage. */
+function requireAliasDecl(lowerer, decl) {
+    return (decl.initializer !== undefined &&
+        requireSpecOf(decl.initializer) !== null &&
+        !isNativeFfiRequire(lowerer, decl.initializer) &&
+        !isJsonRequireDecl(lowerer, decl) &&
+        isJsSourceFile(decl.getSourceFile()));
+}
+/** The registrations a top-level require declaration does make. `const
+ * process = require('node:process')` aliases the global process
+ * (stdlibGlobalAliasDecl's require form) so reads through the binding
+ * lower via the process surface. In `const { codes: { ERR_X } } =
+ * require("./errors")` the outer keys stay alias plumbing, but a nested
+ * pattern destructures the export's value at the require, so its bindings
+ * own storage like any destructured declaration (lowerVarDeclarator
+ * assigns them). */
+function registerRequireDeclBindings(lowerer, sf, list, decl, tag) {
+    if ((list.flags & ts.NodeFlags.Const) !== 0)
+        stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer);
+    const isLetList = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
+    for (const element of requireNestedPatternsOf(decl)) {
+        for (const nameNode of boundIdentifiersOf(element.name)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+            if (!symbol || lowerer.globalsBySymbol.has(symbol))
+                continue;
+            const mapped = lowerer.mapTypeOf(lowerer.typeOf(nameNode));
+            const type = mapped && mapped.kind !== "void" ? mapped : DYN;
+            const g = {
+                id: `%g.${tag}${nameNode.text}`,
+                name: nameNode.text,
+                type,
+                mutable: isLetList,
+                source: bindingSource(nameNode),
+                ...((type.kind === "func" || type.kind === "dyn") && !isVarDeclared(decl)
+                    ? { tdz: true }
+                    : {}),
+            };
+            lowerer.globalsBySymbol.set(symbol, g);
+            lowerer.globalsList.push(g);
+            if (isVarDeclared(decl))
+                noteVarGlobalEntryInit(lowerer, sf, g);
+        }
+    }
+}
 /** The nested half of module-scope `var` hoisting: a `var` inside a
  * top-level BLOCK (an if arm, a loop body, a try) is module-scoped in
  * JS — other functions in the file read the same binding — so it must
@@ -2248,7 +2529,13 @@ function collectNestedVarGlobals(lowerer, sf, stmt, tag) {
         return undefined;
     });
     for (const list of lists) {
-        for (const decl of list.declarations) {
+        for (const decl of list.declarations.nodes) {
+            // A nested builtin require (`if (c) { var fs = require("fs"); }`)
+            // lowers to nothing: its bindings are alias plumbing wherever the
+            // statement sits (lowerVarDeclarator), so they own no storage.
+            if (requireAliasDecl(lowerer, decl) &&
+                canonicalBuiltinModule(requireSpecOf(decl.initializer)) !== null)
+                continue;
             for (const nameNode of boundIdentifiersOf(decl.name)) {
                 const diagsBefore = lowerer.diags.length;
                 try {
@@ -2320,7 +2607,7 @@ export function declSymbolOf(lowerer, decl) {
         ts.getModifiers(decl)?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) === true;
     if (!isDefault)
         return undefined;
-    const sym = defaultExportSymbolOf(lowerer, decl.getSourceFile());
+    const sym = defaultExportSymbolOf(lowerer, ts.getSourceFileOfNode(decl));
     return sym ?? undefined;
 }
 /** `export default <expr>` in a module's init body: the first (and only)
@@ -2337,7 +2624,7 @@ export function declSymbolOf(lowerer, decl) {
  * expression so the expression's OWN diagnostic wins when it has one,
  * then poisons. */
 export function lowerDefaultExport(lowerer, stmt) {
-    const symbol = defaultExportSymbolOf(lowerer, stmt.getSourceFile());
+    const symbol = defaultExportSymbolOf(lowerer, ts.getSourceFileOfNode(stmt));
     if (symbol && symbol.flags & ts.SymbolFlags.Alias && !lowerer.globalsBySymbol.has(symbol))
         return null;
     const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
@@ -2350,10 +2637,10 @@ export function lowerDefaultExport(lowerer, stmt) {
             while (ts.isParenthesizedExpression(inner))
                 inner = inner.expression;
             if (ts.isClassExpression(inner) &&
-                !isJsSourceFile(stmt.getSourceFile()) &&
+                !isJsSourceFile(ts.getSourceFileOfNode(stmt)) &&
                 inner.typeParameters === undefined &&
                 (decoratorNodesOf(inner).length > 0 ||
-                    inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
+                    inner.members.nodes.some((m) => decoratorNodesOf(m).length > 0)) &&
                 guaranteedDecorationThrow(lowerer, inner) !== null) {
                 return { kind: "exprStmt", expr: lowerer.lowerExpr(stmt.expression), loc: locOf(stmt) };
             }
@@ -2392,6 +2679,37 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 loc: loc0,
             });
         }
+        if (sf === lowerer.entry)
+            header.push(...lowerer.punycodeLinkWarning());
+        // Top-level `this` of a CommonJS module: its object exists before the
+        // module's first statement (lowerCjsTopLevelThis).
+        const exportsThis = lowerer.cjsExportsThis.get(sf);
+        if (exportsThis) {
+            header.push({
+                kind: "assign",
+                localId: exportsThis.id,
+                value: { kind: "dynObjLit", fields: [], type: DYN, loc: loc0 },
+                loc: loc0,
+            });
+        }
+        // Reassigned function declarations are initialized when the module
+        // starts, as declarations are hoisted: before its dependencies run, so
+        // a module of an import cycle can call one while it initializes. Their
+        // statements then lower to nothing (rebindable-functions.ts).
+        for (const stmt of stmts) {
+            if (!ts.isFunctionDeclaration(stmt) || !stmt.name || !isRebindableFunction(lowerer, stmt))
+                continue;
+            const g = lowerer.globalsByDeclNode.get(stmt);
+            if (!g)
+                continue;
+            header.push({
+                kind: "assign",
+                localId: g.id,
+                value: lowerer.coerceToExpected(lowerer.lowerLambda(stmt), DYN),
+                loc: locOf(stmt),
+            });
+            ctx.hoistedFnDecls.add(stmt);
+        }
         for (const { stmt, dep } of orderedImportsOf(lowerer.program, sf)) {
             const npm = lowerer.npmInitActions.get(sf)?.get(stmt);
             if (npm !== undefined && npm.length > 0) {
@@ -2446,6 +2764,12 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                     }
                     else {
                         header.push({ kind: "exprStmt", expr: call, loc });
+                        // An ES-module importer links a CommonJS dependency: Node
+                        // copies its lexer-visible exports here.
+                        if ((ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt)) &&
+                            !isCjsJsFile(sf, lowerer.program) &&
+                            isCjsJsFile(dep, lowerer.program))
+                            header.push(...cjsAccessorSnapshotStores(lowerer, dep, loc));
                     }
                 }
             }
@@ -2501,12 +2825,27 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         // a function called above the declaration reads `undefined`, exactly
         // Node); checked-dynamic var globals hold the dyn undefined the same
         // way. After the guard: a cache-hit revisit must not reset them.
+        // A union slot the body retypes checked-dynamic (lowerVarDecl: a
+        // JavaScript var initialized with an existing checked-dynamic object)
+        // gets the dyn undefined once the body has lowered.
+        const unionEntryInits = [];
         for (const g of lowerer.varGlobalEntryInits.get(sf) ?? []) {
             if (g.type.kind !== "union" && g.type.kind !== "dyn")
                 continue;
             const wrapped = g.type.kind === "dyn" ? dynUndefinedExpr(loc0) : lowerer.unassignedSlotInit(g.type, loc0);
             if (wrapped) {
-                header.push({ kind: "assign", localId: g.id, value: wrapped, loc: loc0 });
+                if (g.type.kind === "union")
+                    unionEntryInits.push({ at: header.length, g });
+                // A let global whose early reads are checked (initFlag) only
+                // gets its storage filled here: this is not the source write, so
+                // it must neither run the TDZ check nor set the flag.
+                header.push({
+                    kind: "assign",
+                    localId: g.id,
+                    value: wrapped,
+                    ...(g.initFlag !== undefined ? { initializes: true } : {}),
+                    loc: loc0,
+                });
             }
         }
         const prelude = lowerer.jsonInitActions.get(sf) ?? [];
@@ -2526,7 +2865,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         c.decl &&
             ts.isClassDeclaration(c.decl) &&
             !c.mixinInstance &&
-            c.decl.getSourceFile() === sf &&
+            ts.getSourceFileOfNode(c.decl) === sf &&
             (lowerer.classInitFlags.has(c.def.name) ||
                 c.callableBase !== undefined ||
                 c.def.baseValueGlobal !== undefined ||
@@ -2534,7 +2873,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 c.staticFields.length > 0 ||
                 (c.staticBlocks?.length ?? 0) > 0 ||
                 c.classDecorators !== undefined))
-            .map((c) => ({ pos: c.decl.getStart(), info: c }));
+            .map((c) => ({ pos: ts.tokenStartOfNode(c.decl), info: c }));
         // Statics-bearing MIXIN instantiations whose call evaluates in THIS
         // file: their declaration-time code runs when the call does — the
         // top-level statement lower-mixins recorded. Insertion order is
@@ -2555,7 +2894,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
             // anything the statement's lowering emits. Hoisted class
             // declarations never share a kept statement's start, so `<=`
             // changes nothing for them.
-            while (at < statics.length && statics[at].pos <= stmt.getStart()) {
+            while (at < statics.length && statics[at].pos <= ts.tokenStartOfNode(stmt)) {
                 body.push(...withClassInitFlag(lowerer, statics[at].info, lowerer.lowerStaticFieldInits(statics[at].info)));
                 at++;
             }
@@ -2574,6 +2913,17 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
             body.push(...withClassInitFlag(lowerer, statics[at].info, lowerer.lowerStaticFieldInits(statics[at].info)));
             at++;
         }
+        for (const { at, g } of unionEntryInits) {
+            if (g.type.kind !== "dyn")
+                continue;
+            body[at] = {
+                kind: "assign",
+                localId: g.id,
+                value: dynUndefinedExpr(loc0),
+                ...(g.initFlag !== undefined ? { initializes: true } : {}),
+                loc: loc0,
+            };
+        }
         const moduleRef = cjsModuleRef(lowerer, sf);
         if (moduleRef !== null) {
             const guardedBody = body.splice(guardId !== undefined ? 2 : 0);
@@ -2726,6 +3076,7 @@ function rememberEvaluationError(lowerer, guardId, body, loc) {
 export function buildMain(lowerer) {
     const loc = { file: lowerer.entry.fileName, start: 0, end: 0 };
     const body = [
+        ...lowerer.mainPrelude,
         ...cjsModuleRegistryPrelude(lowerer, loc),
         ...handleEventReaderPrelude(lowerer, loc),
     ];