@scriptc/compiler 0.3.6 → 0.4.0

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

@@ -14,18 +14,24 @@ 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";
@@ -42,6 +48,8 @@ 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";
 /** 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
@@ -113,7 +121,7 @@ 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) {
+        for (const stmt of sf.statements.nodes) {
             if (ts.isFunctionDeclaration(stmt))
                 fp.fnDecls.push(stmt);
             else if (ts.isClassDeclaration(stmt))
@@ -162,9 +170,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);
@@ -233,7 +241,7 @@ 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;
+            const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
             if (heritage && ts.isCallExpression(heritage))
                 computed.add(decl);
         }
@@ -249,7 +257,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 +294,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 +305,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 +314,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 +386,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 +400,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 +418,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 +503,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 +517,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 +549,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 +559,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 +739,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 +938,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 +956,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 +1020,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)) {
@@ -1078,10 +1097,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 +1123,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;
                 }
@@ -1191,7 +1210,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 +1221,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 +1232,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 +1244,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 +1257,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 +1303,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 +1346,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 +1354,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 +1383,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 +1399,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 +1424,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 +1441,45 @@ 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)))) {
+                stmt.declarationList.declarations.nodes.some((decl) => isNativeFfiRequire(lowerer, decl.initializer) || isJsonRequireDecl(lowerer, decl)))) {
             if (ts.isVariableStatement(stmt) && (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
-                for (const decl of stmt.declarationList.declarations) {
+                for (const decl of stmt.declarationList.declarations.nodes) {
                     stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer);
                 }
             }
+            // `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).
+            if (ts.isVariableStatement(stmt)) {
+                const isLetList = (stmt.declarationList.flags & ts.NodeFlags.Let) !== 0 ||
+                    (stmt.declarationList.flags & ts.NodeFlags.BlockScoped) === 0;
+                for (const decl of stmt.declarationList.declarations.nodes) {
+                    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);
+                        }
+                    }
+                }
+            }
             continue;
         }
         // `declare const __VERSION__: string` — AMBIENT: no storage exists
@@ -1391,7 +1487,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 +1502,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
@@ -1532,6 +1629,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 +1743,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 +1767,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 = {
@@ -1717,6 +1818,31 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         }
                         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 = {
+                                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 JS file-scope evolving ARRAY (`const mustCallChecks = [];`
                     // — test/common's exit-accounting ledger): the strict type
                     // (any[]) has no mapping, but the VALUE is the dyn array the
@@ -1755,7 +1881,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 +1924,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 +1950,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 +2035,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 +2097,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 +2118,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 +2178,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 +2324,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
@@ -2248,7 +2408,7 @@ 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) {
             for (const nameNode of boundIdentifiersOf(decl.name)) {
                 const diagsBefore = lowerer.diags.length;
                 try {
@@ -2320,7 +2480,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 +2497,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 +2510,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 +2552,19 @@ 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,
+            });
+        }
         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 +2619,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 +2680,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 +2720,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 +2728,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 +2749,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 +2768,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 +2931,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),
     ];