@scriptc/compiler 0.3.6 → 0.4.0

package/dist/frontend/program.js

@@ -44,19 +44,20 @@ import * as ts from "./ts7/adapter.js";
 import { commonJsModuleSyntaxDiag, invalidPackageConfigDiag, strictNullChecksFloorDiag, tscPassthroughDiag, unsupportedDiag, } from "../diagnostics/diagnostic.js";
 import { isNodeModulesPath, nearestInvalidPackageJsonPath, nearestPackageType, nearestPkgJsonPath, packageImportTarget, projectDtsRuntimeSibling, resolveBareModule, resolveProjectModule, resolveTypeDirective, setProjectPathMappings, setProjectRealm, } from "./resolve.js";
 import { probeNodeImportRefusal, probeNodeRequireRefusal } from "./npm.js";
-import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticDeclarationOverloads, setNpmStaticPackages, } from "./npm-static.js";
+import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, npmStaticLexerVisibleNames, npmStaticLiveExportTable, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticDeclarationOverloads, setNpmStaticPackages, } from "./npm-static.js";
 import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.js";
 import { isNpmStaticSubclassArgument } from "./npm-static-subtyping.js";
 import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties, } from "./npm-static-declaration-syntax.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
 import { cjsLexedExportsOfFile, cjsVisibleNames } from "./cjs-syntax.js";
 import { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath, tsgoPath, } from "./dts-paths.js";
-import { builtinDefaultImportModule, canonicalBuiltinModule, SUPPORTED_NODE_MODULES, unsupportedModuleFeatureOf, } from "./builtin-modules.js";
+import { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_NODE_MODULES, unsupportedModuleFeatureOf, TEMPORAL_GLOBAL, } from "./builtin-modules.js";
 import { clearWorkspacePackages, isRelativeSpecifier, isWorkspacePackageName, npmPackageNameOf, registerWorkspacePackage, workspacePackageOfPath, } from "./workspace-registry.js";
 import { ADOPTED_OPTIONS, isJsSourceFileName, JS_ANY_OPERATOR_CODES, JS_RELAXED_TSC_CODES, } from "./tsc-codes.js";
 import { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
 import { forkTargetPaths } from "./fork-target.js";
 import { workerTargetPaths } from "./worker-target.js";
+import { erasedTypeOnlyImport, typeOnlyNamedImport, typeOnlyReachedFiles, } from "./type-only-imports.js";
 import { moduleSourceCandidates } from "./module-source-candidates.js";
 import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
 const BASE_OPTIONS = {
@@ -74,11 +75,16 @@ const FORCED_OPTIONS = {
     // classification is intentionally independent below; this option is only
     // the binder's scope decision.
     moduleDetection: ts.ModuleDetectionKind.Force,
-    // Explicit resource management and Array.fromAsync are ESNext library
-    // slices in TS 7 even though Node 24 ships them. Include those focused
-    // libs without widening the rest of the standard-library target past
-    // ES2025.
-    lib: ["lib.es2025.d.ts", "lib.esnext.disposable.d.ts", "lib.esnext.array.d.ts"],
+    // Explicit resource management, Array.fromAsync and Error.isError are
+    // ESNext library slices in TS 7 even though Node 24 ships them. Include
+    // those focused libs without widening the rest of the standard-library
+    // target past ES2025.
+    lib: [
+        "lib.es2025.d.ts",
+        "lib.esnext.disposable.d.ts",
+        "lib.esnext.array.d.ts",
+        "lib.esnext.error.d.ts",
+    ],
     types: [],
     allowImportingTsExtensions: true,
     allowJs: true,
@@ -221,6 +227,7 @@ function adoptProjectConfig7(host, entryPath) {
         diags,
         ...(projectLib === undefined ? {} : { projectLib }),
         forcedStrictNullChecks,
+        checkJs: parsed.options["checkJs"] === true,
     };
 }
 /** The target project's @types/node, resolved with the OWN resolver's
@@ -409,12 +416,12 @@ function createRequireProgramRoots7(program) {
         const calls = [];
         for (const node of moduleSourceCandidates(program, sf).calls) {
             if (node.questionDotToken !== undefined ||
-                node.arguments.length !== 1 ||
-                !ts.isStringLiteralLike(node.arguments[0]) ||
+                node.arguments.nodes.length !== 1 ||
+                !ts.isStringLiteralLike(node.arguments.nodes[0]) ||
                 !ts.isIdentifier(node.expression)) {
                 continue;
             }
-            calls.push({ callee: node.expression, spec: node.arguments[0].text });
+            calls.push({ callee: node.expression, spec: node.arguments.nodes[0].text });
         }
         // Root discovery only needs the callee's binding. A first-miss lookup
         // otherwise fetches symbols and types for every identifier in the file,
@@ -462,9 +469,10 @@ export function entryPackageFilePredicate(entryPath) {
     };
 }
 /** maxNodeModuleJsDepth can omit relative imports within an admitted
- * package. Discover its runtime sources to a fixpoint so the checker and
- * module resolver see the same graph regardless of import traversal order. */
-function entryPackageProgramRoots7(program, entryPath) {
+ * package, and opted-in packages deep in the dependency graph. Discover
+ * their runtime sources to a fixpoint so the checker and module resolver
+ * see the same graph regardless of import traversal order or depth. */
+function entryPackageProgramRoots7(program, entryPath, rootNpmStaticEdges) {
     const belongsToEntry = entryPackageFilePredicate(entryPath);
     const roots = new Set();
     for (const sf of program.getImplementationSourceFiles()) {
@@ -480,11 +488,80 @@ function entryPackageProgramRoots7(program, entryPath) {
                 isJsSourceFileName(target) &&
                 program.getSourceFile(target) === undefined)
                 roots.add(target);
+            // An opted-in package's bare edge counts against the same depth
+            // budget: tsgo charges every node_modules JS hop, so express's
+            // body-parser → qs → side-channel → get-intrinsic chain runs out of
+            // depth before its leaves load. Root the runtime file this edge
+            // lowers to (preflight's own resolution and miss rule) so the leaf
+            // joins like a shallow one; complete programs add nothing. Only
+            // the shadowed lowering world does this (the authored world checks
+            // user code against declarations), and only from package files: a
+            // program file's own edges are never deeper than one hop.
+            // (resolveBareModule directly: resolveNpmImport7's workspace
+            // registration stays with preflight's own walk.)
+            if (target === null &&
+                rootNpmStaticEdges &&
+                npmStaticPackageOfPath(sf.fileName) !== null &&
+                !isRelativeSpecifier(specifier.text)) {
+                const spec = specifier.text;
+                if (spec.startsWith("#") || canonicalBuiltinModule(spec) !== null)
+                    continue;
+                const npm = resolveBareModule(sf.fileName, spec, undefined, moduleSpecifierKind7(specifier));
+                if (npm !== null &&
+                    isNpmStaticPackage(npm.packageName) &&
+                    (isNodeModulesPath(npm.typesFile) || npm.workspaceDir !== undefined) &&
+                    isJsSourceFileName(npm.typesFile) &&
+                    npmStaticProgramFile(program, npm.typesFile) === null)
+                    roots.add(tsgoPath(resolve(npm.typesFile)));
+            }
         }
     }
     return [...roots].sort();
 }
-function loadProgram7(host, entryPath, externalTypes = new Map()) {
+/** TS 7's ESNext temporal declarations: a lib slice scriptc adds only for
+ * programs whose sources name the global (programNamesTemporal7). */
+const TEMPORAL_LIB = "lib.esnext.temporal.d.ts";
+/** True when a program source (user code or compiled npm JavaScript)
+ * contains the temporal global's name as a whole word. A cheap syntactic
+ * scan of the implementation files root discovery already materialized; a
+ * mention in a comment or string also counts, which only adds the lib
+ * slice. */
+function programNamesTemporal7(program) {
+    for (const sf of program.getImplementationSourceFiles()) {
+        const text = sf.text;
+        for (let at = text.indexOf(TEMPORAL_GLOBAL); at >= 0; at = text.indexOf(TEMPORAL_GLOBAL, at + 8)) {
+            if (!isIdentifierCharAt(text, at - 1) && !isIdentifierCharAt(text, at + 8))
+                return true;
+        }
+    }
+    return false;
+}
+function isIdentifierCharAt(text, index) {
+    if (index < 0 || index >= text.length)
+        return false;
+    const c = text.charCodeAt(index);
+    return ((c >= 48 && c <= 57) ||
+        (c >= 65 && c <= 90) ||
+        (c >= 97 && c <= 122) ||
+        c === 36 ||
+        c === 95 ||
+        c > 127);
+}
+/** "require" for a CommonJS edge (`require("x")`, `import x = require("x")`),
+ * "import" for every ESM form — the resolution kind preflight uses. */
+function moduleSpecifierKind7(specifier) {
+    const parent = specifier.parent;
+    if (ts.isExternalModuleReference(parent))
+        return "require";
+    return ts.isCallExpression(parent) &&
+        ts.isIdentifier(parent.expression) &&
+        parent.expression.text === "require"
+        ? "require"
+        : "import";
+}
+function loadProgram7(host, entryPath, externalTypes = new Map(), 
+/** The --npm-static lowering world: root opted-in packages' deep edges. */
+rootNpmStaticEdges = false) {
     const config = adoptProjectConfig7(host, entryPath);
     const configuredPaths = config.options["paths"];
     setProjectPathMappings(configuredPaths !== undefined && typeof configuredPaths === "object" && configuredPaths !== null
@@ -530,7 +607,7 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
     try {
         for (let pass = 0; pass < 32; pass++) {
             const candidates = [
-                ...entryPackageProgramRoots7(program, entryPath),
+                ...entryPackageProgramRoots7(program, entryPath, rootNpmStaticEdges),
                 ...createRequireProgramRoots7(program),
                 ...forkTargetPaths(program, program.getImplementationSourceFiles()),
                 ...workerTargetPaths(program, program.getImplementationSourceFiles()),
@@ -544,6 +621,20 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
             if (pass === 31)
                 throw new Error("static program-root discovery did not converge");
         }
+        // Node 24 ships no temporal global, but TS 7 types it in an ESNext
+        // lib slice. Programs that name it (feature probes such as smol-toml's
+        // typeof check) get that slice so they type-check, and lower to Node's
+        // answers (typeof "undefined", ReferenceError on use). Every other
+        // program keeps the identical lib set: the slice would add globals to
+        // the checker's world for everyone.
+        if (programNamesTemporal7(program)) {
+            program.dispose();
+            options = {
+                ...options,
+                lib: [...(options.lib ?? []), TEMPORAL_LIB],
+            };
+            program = host.createProgram([...programRoots, overridesDtsPath()], options);
+        }
         const entry = program.getSourceFile(entryPath);
         if (!entry)
             throw new Error(`could not load ${entryPath}`);
@@ -558,6 +649,7 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
                 nodeFallback: nodeTypes === null,
                 projectLib: config.projectLib ?? null,
                 forcedStrictNullChecks: config.forcedStrictNullChecks ?? false,
+                projectCheckJs: config.checkJs ?? false,
             },
             externalTypes,
             externalTypeSpecifiersByFile,
@@ -712,7 +804,7 @@ export function loadProgram(entryPath, services, opts) {
     };
     const host = services.createProgramHost({ cwd: dirname(entryPath), fsShadow });
     try {
-        const load = loadProgram7(host, entryPath, externalTypes);
+        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0);
         let authoredHost = null;
         let authoredLoad = null;
         return {
@@ -757,9 +849,10 @@ export function loadProgram(entryPath, services, opts) {
  * preflight diagnostics. Preserve the caller's complete load shape when
  * mutating it, including its owned services and disposal callback. */
 export function checkPreflight(load) {
-    const { diags, moduleOrder, startupCrash } = preflight7(load);
+    const { diags, moduleOrder, startupCrash, inlineRequireCycleCalls } = preflight7(load);
     load.moduleOrder = moduleOrder;
     load.startupCrash = startupCrash;
+    load.inlineRequireCycleCalls = inlineRequireCycleCalls;
     return diags;
 }
 /* Finding 5: tsgo's strict CommonJS modeling fires checker codes on JS
@@ -779,6 +872,13 @@ export function checkPreflight(load) {
 // retains only their call signature after a factory return. Heritage
 // lowering separately verifies the actual constructor implementation.
 const TS7_JS_RELAXED_EXTRA = new Set([2309, 2323, 2507]);
+/** Relaxed JavaScript codes that checked JavaScript files keep: values of
+ * another type in a typed slot (2322 and its elaborations 2740/2741/2559,
+ * 2345, 2769), call arity (2554-2556) and incompatible subclass members
+ * (2415). */
+const CHECKED_JS_ENFORCED_CODES = new Set([
+    2322, 2345, 2415, 2554, 2555, 2556, 2559, 2740, 2741, 2769,
+]);
 function suppressedJsStrictness7(d) {
     const file = d.fileName;
     if (!file || !isJsSourceFileName(file))
@@ -812,9 +912,9 @@ function requireSpecOf7(node) {
         return null;
     if (!ts.isIdentifier(value.expression) || value.expression.text !== "require")
         return null;
-    if (value.arguments.length !== 1)
+    if (value.arguments.nodes.length !== 1)
         return null;
-    const arg = value.arguments[0];
+    const arg = value.arguments.nodes[0];
     return ts.isStringLiteral(arg) ? arg.text : null;
 }
 /** True for statements that are CommonJS require IMPORTS at a module's top
@@ -827,7 +927,7 @@ function isRequireStatement7(stmt) {
         return requireSpecOf7(stmt.expression) !== null;
     if (!ts.isVariableStatement(stmt))
         return false;
-    const decls = stmt.declarationList.declarations;
+    const decls = stmt.declarationList.declarations.nodes;
     return (decls.length > 0 &&
         decls.every((d) => d.initializer !== undefined && requireSpecOf7(d.initializer) !== null));
 }
@@ -841,7 +941,7 @@ function requiresOf7(stmt) {
     if (!ts.isVariableStatement(stmt))
         return [];
     const out = [];
-    for (const decl of stmt.declarationList.declarations) {
+    for (const decl of stmt.declarationList.declarations.nodes) {
         const spec = decl.initializer !== undefined ? requireSpecOf7(decl.initializer) : null;
         if (spec !== null)
             out.push({ spec, node: decl, decl });
@@ -861,9 +961,9 @@ export function isEsModuleStamp(expr) {
         callee.name.text !== "defineProperty") {
         return false;
     }
-    if (expr.arguments.length !== 3)
+    if (expr.arguments.nodes.length !== 3)
         return false;
-    const [recv, nameArg, desc] = expr.arguments;
+    const [recv, nameArg, desc] = expr.arguments.nodes;
     const isExports = (ts.isIdentifier(recv) && recv.text === "exports") ||
         (ts.isPropertyAccessExpression(recv) &&
             ts.isIdentifier(recv.expression) &&
@@ -874,9 +974,9 @@ export function isEsModuleStamp(expr) {
         return false;
     if (!ts.isStringLiteral(nameArg) || nameArg.text !== "__esModule")
         return false;
-    if (!ts.isObjectLiteralExpression(desc) || desc.properties.length !== 1)
+    if (!ts.isObjectLiteralExpression(desc) || desc.properties.nodes.length !== 1)
         return false;
-    const p = desc.properties[0];
+    const p = desc.properties.nodes[0];
     return (ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
         p.name.text === "value" &&
@@ -890,13 +990,13 @@ function pureCjsExport7(program, stmt) {
     const cjs = cjsExportAssignmentOf(stmt);
     if (cjs === null)
         return false;
-    const sf = stmt.getSourceFile();
+    const sf = ts.getSourceFileOfNode(stmt);
     const plainMember = (left) => {
         if (!ts.isPropertyAccessExpression(left) || left.questionDotToken)
             return false;
         // A replacement export can have setters or non-writable function
         // properties. Only the wrapper's original object gets this exception.
-        if (sf.statements.some((s) => cjsExportAssignmentOf(s)?.kind === "table"))
+        if (sf.statements.nodes.some((s) => cjsExportAssignmentOf(s)?.kind === "table"))
             return false;
         if (left.name.text === "__proto__" || left.name.text === "__esModule")
             return false;
@@ -938,17 +1038,13 @@ function pureCjsExport7(program, stmt) {
     const checker = program.getTypeChecker();
     const symbol = checker.getSymbolAtLocation(value);
     return (symbol !== undefined &&
-        checker
-            .declarationsOf(symbol)
-            .some((decl) => ts.isFunctionDeclaration(decl) && decl.parent === stmt.parent));
+        symbol.declarations.some((decl) => ts.isFunctionDeclaration(decl) && decl.parent === stmt.parent));
 }
 function sourceBinding7(program, ident) {
     const checker = program.getTypeChecker();
     const symbol = checker.getSymbolAtLocation(ident);
     return (symbol !== undefined &&
-        checker
-            .declarationsOf(symbol)
-            .some((decl) => !decl.getSourceFile().isDeclarationFile && !ts.isSourceFile(decl)));
+        symbol.declarations.some((decl) => !ts.getSourceFileOfNode(decl).isDeclarationFile && !ts.isSourceFile(decl)));
 }
 function purePrefixDecl7(decl) {
     const init = decl.initializer;
@@ -972,11 +1068,11 @@ function purePrefixStmt7(program, s) {
         return true; // directive
     if (isRequireStatement7(s))
         return true;
-    if (isCjsJsFile7(s.getSourceFile(), program)) {
+    if (isCjsJsFile7(ts.getSourceFileOfNode(s), program)) {
         if (ts.isExpressionStatement(s) && isEsModuleStamp(s.expression)) {
             const call = s.expression;
             const object = call.expression.expression;
-            let receiver = call.arguments[0];
+            let receiver = call.arguments.nodes[0];
             if (ts.isPropertyAccessExpression(receiver))
                 receiver = receiver.expression;
             if (!sourceBinding7(program, object) &&
@@ -988,7 +1084,7 @@ function purePrefixStmt7(program, s) {
             return true;
     }
     if (ts.isVariableStatement(s)) {
-        return s.declarationList.declarations.every(purePrefixDecl7);
+        return s.declarationList.declarations.nodes.every(purePrefixDecl7);
     }
     return false;
 }
@@ -1012,7 +1108,7 @@ export function bindingEarlyUse7(program, sf, k, decl, precedingDecls) {
     if (ts.isIdentifier(decl.name))
         bound.push(decl.name);
     else if (ts.isObjectBindingPattern(decl.name)) {
-        for (const el of decl.name.elements)
+        for (const el of decl.name.elements.nodes)
             if (el.name !== undefined && ts.isIdentifier(el.name))
                 bound.push(el.name);
     }
@@ -1024,7 +1120,7 @@ export function bindingEarlyUse7(program, sf, k, decl, precedingDecls) {
     }
     if (bindings.size === 0)
         return null;
-    const stmts = sf.statements;
+    const stmts = sf.statements.nodes;
     const hoisted = new Map();
     for (const s of stmts) {
         if ((ts.isFunctionDeclaration(s) || ts.isClassDeclaration(s)) && s.name) {
@@ -1083,6 +1179,542 @@ export function bindingEarlyUse7(program, sf, k, decl, precedingDecls) {
     }
     return hit;
 }
+/** The first reference to a top-level require declaration's bindings that
+ * code running before the require completes can reach, or null when no
+ * earlier code can run or reach one. Memoized per program: preflight
+ * decides the fence and the lowering places the initialization checks
+ * from the same answer. */
+function requireEarlyReference7(program, decl) {
+    const memo = program.analysis.requireEarlyReferences;
+    const cached = memo.get(decl);
+    if (cached !== undefined)
+        return cached;
+    let found = null;
+    const stmt = decl.parent?.parent;
+    const sf = ts.getSourceFileOfNode(decl);
+    if (stmt !== undefined && ts.isVariableStatement(stmt) && ts.isSourceFile(stmt.parent)) {
+        const stmts = sf.statements.nodes;
+        const k = stmts.indexOf(stmt);
+        const declarations = stmt.declarationList.declarations.nodes;
+        // Earlier declarators run too: `const x = read(), dep = require('./dep')`.
+        const precedingDecls = declarations.slice(0, declarations.indexOf(decl));
+        let firstRunnable = program.analysis.requireFirstRunnable.get(sf);
+        if (firstRunnable === undefined) {
+            firstRunnable = stmts.findIndex((s) => !purePrefixStmt7(program, s));
+            program.analysis.requireFirstRunnable.set(sf, firstRunnable);
+        }
+        const prefixCanRun = (firstRunnable >= 0 && firstRunnable < k) || precedingDecls.some((d) => !purePrefixDecl7(d));
+        if (prefixCanRun)
+            found = requireBindingEarlyUse7(program, sf, k, decl, precedingDecls);
+    }
+    memo.set(decl, found);
+    return found;
+}
+/** The CommonJS twin of bindingEarlyUse7 for a top-level require binding:
+ * the first reference to one of `decl`'s bindings that code running before
+ * the require completes can reach, or null. It follows Node's evaluation
+ * order instead of the conservative "every earlier statement" scan:
+ *  - hoisted functions and classes, and the function and class values a
+ *    var stored before the require, run only when reachable code names
+ *    them; a class statement runs only its heritage, computed keys,
+ *    decorators and static initializers;
+ *  - callbacks handed to timers, microtasks and promise reactions run after
+ *    the module body, hence after the require;
+ *  - publishing a value (`module.exports = f`, `exports.n = f`,
+ *    `Object.defineProperty(exports, "n", { get })`, `F.prototype.m = f`)
+ *    runs nothing. The published value becomes reachable only when
+ *    reachable code reads it back: an `exports.n` read reaches the values
+ *    published as `n`, any other read of the export object reaches all of
+ *    them, and naming `F` reaches what was stored on `F`. No other module
+ *    can read this module's exports before its body completes: require
+ *    cycles keep their SC1016 fence and a compiled module graph has no
+ *    reflective exports object.
+ * Every other function-like met in reachable code counts as reachable
+ * because it may be handed to a callee. */
+export function requireBindingEarlyUse7(program, sf, k, decl, precedingDecls, 
+/** A reference of the binding whose early evaluation is known exact. */
+exactEarlyRead) {
+    const checker = program.getTypeChecker();
+    const bindings = new Set();
+    for (const id of boundNames7(decl.name)) {
+        const sym = checker.getSymbolAtLocation(id);
+        if (sym)
+            bindings.add(sym);
+    }
+    if (bindings.size === 0)
+        return null;
+    const stmts = sf.statements.nodes;
+    const cjs = isCjsJsFile7(sf, program);
+    const symbolOf = (id) => {
+        const parent = id.parent;
+        if (parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === id) {
+            return checker.getShorthandAssignmentValueSymbol(parent);
+        }
+        return checker.getSymbolAtLocation(id);
+    };
+    // Stored callables and the scans that skip them.
+    const units = new Map();
+    const stored = new Set();
+    const addUnit = (name, node) => {
+        const sym = checker.getSymbolAtLocation(name);
+        if (sym === undefined)
+            return;
+        stored.add(node);
+        const list = units.get(sym);
+        if (list)
+            list.push(node);
+        else
+            units.set(sym, [node]);
+    };
+    const storedCallables = (e, out) => {
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (ts.isArrowFunction(e) || ts.isFunctionExpression(e) || ts.isClassExpression(e)) {
+            out.push(e);
+        }
+        else if (ts.isObjectLiteralExpression(e)) {
+            for (const p of e.properties.nodes) {
+                if ((ts.isMethodDeclaration(p) ||
+                    ts.isGetAccessorDeclaration(p) ||
+                    ts.isSetAccessorDeclaration(p)) &&
+                    !ts.isComputedPropertyName(p.name)) {
+                    out.push(p);
+                }
+                else if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
+                    storedCallables(p.initializer, out);
+                }
+            }
+        }
+    };
+    stmts.forEach((s, i) => {
+        if ((ts.isFunctionDeclaration(s) || ts.isClassDeclaration(s)) && s.name !== undefined) {
+            addUnit(s.name, s);
+        }
+        else if (i < k && ts.isVariableStatement(s)) {
+            for (const d of s.declarationList.declarations.nodes) {
+                if (!ts.isIdentifier(d.name) || d.initializer === undefined)
+                    continue;
+                const out = [];
+                storedCallables(d.initializer, out);
+                for (const node of out)
+                    addUnit(d.name, node);
+            }
+        }
+    });
+    // Callbacks that only run as later jobs never run before the require:
+    // the timers, microtasks and promise reactions. (Event listeners can run
+    // synchronously from an emit, so they keep the conservative rule.)
+    const laterJob = (callee) => {
+        while (ts.isParenthesizedExpression(callee))
+            callee = callee.expression;
+        const name = ts.isIdentifier(callee)
+            ? callee.text
+            : ts.isPropertyAccessExpression(callee)
+                ? callee.name.text
+                : null;
+        return (name !== null &&
+            (LATER_JOB_BUILTINS7.has(name) || name === "nextTick") &&
+            laterJobCallee7(checker, callee));
+    };
+    if (!hasTopLevelAwait7(sf)) {
+        const callbacks = (e) => {
+            while (ts.isParenthesizedExpression(e))
+                e = e.expression;
+            if (ts.isArrowFunction(e) || ts.isFunctionExpression(e))
+                stored.add(e);
+        };
+        for (const s of stmts.slice(0, k)) {
+            ts.walkPreorder(s, (node) => {
+                if ((ts.isCallExpression(node) || ts.isNewExpression(node)) && laterJob(node.expression)) {
+                    for (const arg of node.arguments?.nodes ?? [])
+                        callbacks(arg);
+                }
+                return undefined;
+            });
+        }
+    }
+    const isWrapperName = (e, name) => ts.isIdentifier(e) && e.text === name && !sourceBinding7(program, e);
+    /** `this` at the module's top level: the original export object. */
+    const isModuleThis = (e) => {
+        if (e.kind !== ts.SyntaxKind.ThisKeyword)
+            return false;
+        for (let p = e.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
+            if (ts.isFunctionLike(p) && !ts.isArrowFunction(p))
+                return false;
+            if (ts.isClassExpression(p) || ts.isClassDeclaration(p))
+                return false;
+        }
+        return true;
+    };
+    const isExportObject = (e) => isWrapperName(e, "exports") ||
+        isModuleThis(e) ||
+        (isModuleExportsAccess(e) && isWrapperName(e.expression, "module"));
+    const replacesExports = stmts.some((st) => cjsExportAssignmentOf(st)?.kind === "table");
+    // Published values: by export name ("*" for a whole replacement), and by
+    // the stored callable whose properties hold them.
+    const exportLinks = new Map();
+    const ownerLinks = new Map();
+    const reachedKeys = new Set();
+    const writtenKeys = new Set();
+    const reachedUnits = new Set();
+    const work = [];
+    let hit = null;
+    const reachUnit = (node) => {
+        if (reachedUnits.has(node))
+            return;
+        reachedUnits.add(node);
+        work.push(node);
+    };
+    const reachSymbol = (sym) => {
+        for (const node of units.get(sym) ?? [])
+            reachUnit(node);
+        for (const node of ownerLinks.get(sym) ?? [])
+            reachUnit(node);
+    };
+    let allReached = false;
+    const reachKey = (key) => {
+        if (key === null) {
+            allReached = true;
+            for (const list of exportLinks.values())
+                for (const node of list)
+                    reachUnit(node);
+            return;
+        }
+        reachedKeys.add(key);
+        for (const name of [key, "*"])
+            for (const node of exportLinks.get(name) ?? [])
+                reachUnit(node);
+    };
+    const keyReached = (key) => allReached || reachedKeys.has(key) || (key === "*" && reachedKeys.size > 0);
+    /** A read of the export object: which published names it can observe. */
+    const exportRead = (node) => {
+        let use = node;
+        while (ts.isParenthesizedExpression(use.parent))
+            use = use.parent;
+        const parent = use.parent;
+        // A truthiness test reads no member (tsc's `this && this.__helper`).
+        if (ts.isBinaryExpression(parent) &&
+            parent.left === use &&
+            parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+            return;
+        }
+        if (ts.isTypeOfExpression(parent))
+            return;
+        if (ts.isPropertyAccessExpression(parent) && parent.expression === use) {
+            let target = parent;
+            while (ts.isParenthesizedExpression(target.parent))
+                target = target.parent;
+            const assignment = target.parent;
+            if (ts.isBinaryExpression(assignment) &&
+                assignment.left === target &&
+                assignment.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                // A plain write reads no member. It can still run a setter: one
+                // published for that name (now or later), or a static one of a
+                // replacing class.
+                writtenKeys.add(parent.name.text);
+                for (const node of exportLinks.get(parent.name.text) ?? [])
+                    reachUnit(node);
+                for (const node of exportLinks.get("*") ?? []) {
+                    if (ts.isClassDeclaration(node) || ts.isClassExpression(node))
+                        reachUnit(node);
+                }
+                return;
+            }
+            reachKey(parent.name.text);
+            return;
+        }
+        if (ts.isElementAccessExpression(parent) &&
+            parent.expression === use &&
+            ts.isStringLiteralLike(parent.argumentExpression)) {
+            reachKey(parent.argumentExpression.text);
+            return;
+        }
+        reachKey(null);
+    };
+    const scan = (root) => {
+        ts.walkPreorder(root, (n) => {
+            if (hit !== null)
+                return "stop";
+            if (n !== root && stored.has(n)) {
+                if (ts.isClassExpression(n) || ts.isClassDeclaration(n)) {
+                    for (const part of classSyncParts7(n))
+                        scan(part);
+                }
+                return "skip";
+            }
+            // A self-require answers this module's partially built exports.
+            if (cjs && ts.isCallExpression(n)) {
+                const spec = requireSpecOf7(n);
+                if (spec !== null && resolveImport7(program, sf, spec, "require") === sf)
+                    reachKey(null);
+            }
+            if (cjs && n.kind === ts.SyntaxKind.ThisKeyword && isModuleThis(n)) {
+                exportRead(n);
+                return undefined;
+            }
+            if (!ts.isIdentifier(n))
+                return undefined;
+            if (inTypePosition7(n))
+                return undefined;
+            const named = n.parent;
+            if ((ts.isPropertyAccessExpression(named) ||
+                ts.isPropertyAssignment(named) ||
+                ts.isMethodDeclaration(named) ||
+                ts.isGetAccessorDeclaration(named) ||
+                ts.isSetAccessorDeclaration(named) ||
+                ts.isPropertyDeclaration(named)) &&
+                named.name === n) {
+                return undefined;
+            }
+            // A declaration's own name reads nothing.
+            if (named !== undefined && declaredName7(named) === n)
+                return undefined;
+            if (cjs && isWrapperName(n, "exports")) {
+                exportRead(n);
+                return undefined;
+            }
+            if (cjs && isWrapperName(n, "module")) {
+                const parent = n.parent;
+                if (ts.isPropertyAccessExpression(parent) && parent.expression === n) {
+                    if (parent.name.text === "exports")
+                        exportRead(parent);
+                    return "skip";
+                }
+                reachKey(null);
+                return undefined;
+            }
+            const sym = symbolOf(n);
+            if (sym === undefined)
+                return undefined;
+            if (bindings.has(sym)) {
+                if (exactEarlyRead?.(n) === true)
+                    return undefined;
+                hit = n;
+                return "stop";
+            }
+            reachSymbol(sym);
+            return undefined;
+        });
+    };
+    /** Links a published value: evaluating it reads identifiers, but the
+     * callables it names run only once they are read back. */
+    const publish = (value, link) => {
+        while (ts.isParenthesizedExpression(value))
+            value = value.expression;
+        if (ts.isIdentifier(value)) {
+            const sym = symbolOf(value);
+            if (sym !== undefined && bindings.has(sym)) {
+                hit = value;
+                return;
+            }
+            if (sym !== undefined) {
+                // What was stored on the value stays reachable through it.
+                for (const node of [...(units.get(sym) ?? []), ...(ownerLinks.get(sym) ?? [])])
+                    link(node);
+            }
+            return;
+        }
+        if (ts.isFunctionExpression(value) || ts.isArrowFunction(value)) {
+            link(value);
+            return;
+        }
+        if (ts.isClassExpression(value)) {
+            for (const part of classSyncParts7(value))
+                scan(part);
+            link(value);
+            return;
+        }
+        if (ts.isObjectLiteralExpression(value)) {
+            for (const p of value.properties.nodes) {
+                if (ts.isShorthandPropertyAssignment(p)) {
+                    const sym = checker.getShorthandAssignmentValueSymbol(p);
+                    if (sym !== undefined && bindings.has(sym))
+                        hit = p.name;
+                    else if (sym !== undefined) {
+                        for (const node of [...(units.get(sym) ?? []), ...(ownerLinks.get(sym) ?? [])]) {
+                            link(node);
+                        }
+                    }
+                }
+                else if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
+                    publish(p.initializer, link);
+                }
+                else if ((ts.isMethodDeclaration(p) ||
+                    ts.isGetAccessorDeclaration(p) ||
+                    ts.isSetAccessorDeclaration(p)) &&
+                    !ts.isComputedPropertyName(p.name)) {
+                    link(p);
+                }
+                else
+                    scan(p);
+            }
+            return;
+        }
+        if (ts.isStringLiteralLike(value) ||
+            ts.isNumericLiteral(value) ||
+            value.kind === ts.SyntaxKind.TrueKeyword ||
+            value.kind === ts.SyntaxKind.FalseKeyword ||
+            value.kind === ts.SyntaxKind.NullKeyword ||
+            (ts.isVoidExpression(value) && ts.isNumericLiteral(value.expression))) {
+            return;
+        }
+        scan(value);
+        // Whatever an arbitrary expression evaluates to is opaque: treat it as
+        // reachable through the target too (scan already reached its parts).
+    };
+    const targetOf = (left) => {
+        if (isModuleExportsAccess(left) && isWrapperName(left.expression, "module")) {
+            return { kind: "key", key: "*" };
+        }
+        const names = [];
+        let e = left;
+        for (;;) {
+            if (ts.isPropertyAccessExpression(e) && !e.questionDotToken) {
+                if (isExportObject(e))
+                    break;
+                names.unshift(e.name.text);
+                e = e.expression;
+            }
+            else if (ts.isElementAccessExpression(e) &&
+                !e.questionDotToken &&
+                ts.isStringLiteralLike(e.argumentExpression)) {
+                names.unshift(e.argumentExpression.text);
+                e = e.expression;
+            }
+            else
+                break;
+        }
+        if (names.length === 0)
+            return null;
+        if (isExportObject(e)) {
+            // __proto__ and the interop marker are not plain data slots, and a
+            // member of a replaced export may be a read-only function property:
+            // those writes keep the conservative scan.
+            if (names[0] === "__proto__" || names[0] === "__esModule" || replacesExports)
+                return null;
+            return { kind: "key", key: names[0] };
+        }
+        if (ts.isIdentifier(e)) {
+            const sym = symbolOf(e);
+            if (sym !== undefined && units.has(sym) && !bindings.has(sym))
+                return { kind: "owner", owner: sym };
+        }
+        return null;
+    };
+    const linkTo = (target, node) => {
+        if (target.kind === "key") {
+            const replacingClass = target.key === "*" &&
+                writtenKeys.size > 0 &&
+                (ts.isClassDeclaration(node) || ts.isClassExpression(node));
+            if (keyReached(target.key) || writtenKeys.has(target.key) || replacingClass) {
+                reachUnit(node);
+            }
+            const list = exportLinks.get(target.key);
+            if (list)
+                list.push(node);
+            else
+                exportLinks.set(target.key, [node]);
+        }
+        else {
+            if ((units.get(target.owner) ?? []).some((u) => reachedUnits.has(u)))
+                reachUnit(node);
+            if ((units.get(target.owner) ?? []).includes(node))
+                return;
+            const list = ownerLinks.get(target.owner);
+            if (list === undefined)
+                ownerLinks.set(target.owner, [node]);
+            else if (!list.includes(node))
+                list.push(node);
+        }
+    };
+    /** A top-level publication statement, handled in place; false for any
+     * other statement. */
+    const publication = (s) => {
+        if (!cjs || !ts.isExpressionStatement(s))
+            return false;
+        const e = s.expression;
+        if (ts.isBinaryExpression(e) && e.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            const targets = [];
+            let value = e;
+            while (ts.isBinaryExpression(value) &&
+                value.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                const target = targetOf(value.left);
+                if (target === null)
+                    return false;
+                targets.push(target);
+                value = value.right;
+            }
+            publish(value, (node) => {
+                for (const t of targets)
+                    linkTo(t, node);
+            });
+            return true;
+        }
+        // Object.defineProperty(exports, "name", { get() {...}, value: f, ... })
+        if (ts.isCallExpression(e) &&
+            ts.isPropertyAccessExpression(e.expression) &&
+            isWrapperName(e.expression.expression, "Object") &&
+            e.expression.name.text === "defineProperty" &&
+            e.arguments.nodes.length === 3) {
+            const [recv, key, desc] = e.arguments.nodes;
+            if (!isExportObject(recv) || !ts.isStringLiteralLike(key))
+                return false;
+            if (!ts.isObjectLiteralExpression(desc))
+                return false;
+            const keyTarget = { kind: "key", key: key.text };
+            const link = (node) => linkTo(keyTarget, node);
+            for (const p of desc.properties.nodes) {
+                if ((ts.isMethodDeclaration(p) || ts.isPropertyAssignment(p)) &&
+                    ts.isIdentifier(p.name) &&
+                    (p.name.text === "get" || p.name.text === "set")) {
+                    if (ts.isMethodDeclaration(p))
+                        link(p);
+                    else
+                        publish(p.initializer, link);
+                }
+                else if (ts.isPropertyAssignment(p) &&
+                    ts.isIdentifier(p.name) &&
+                    p.name.text === "value") {
+                    publish(p.initializer, link);
+                }
+                else
+                    scan(p);
+            }
+            return true;
+        }
+        return false;
+    };
+    const drain = () => {
+        while (hit === null && work.length > 0) {
+            const unit = work.pop();
+            checker.prefetchSymbolRoots([unit]);
+            scan(unit);
+        }
+    };
+    const roots = stmts.slice(0, k);
+    checker.prefetchSymbolRoots([...roots, ...precedingDecls]);
+    for (const s of roots) {
+        if (hit !== null)
+            break;
+        if (ts.isFunctionDeclaration(s))
+            continue;
+        if (ts.isClassDeclaration(s)) {
+            for (const part of classSyncParts7(s))
+                scan(part);
+        }
+        else if (!publication(s)) {
+            scan(s);
+        }
+        drain();
+    }
+    for (const d of precedingDecls) {
+        if (hit !== null)
+            break;
+        scan(d);
+        drain();
+    }
+    return hit;
+}
 /** Bare `require("...")` EXPRESSION STATEMENTS anywhere below the top
  * level of a file — inside top-level ifs/blocks/loops and inside function
  * bodies (the lazy-require idiom). No bindings, pure side-effect loads. */
@@ -1101,6 +1733,35 @@ function nestedBareRequiresOf7(sf) {
     });
     return out;
 }
+/** INLINE `require("...")` calls in expression position anywhere in a file
+ * (`require("./x").f`, `require("debug")("ns")`, `module.exports =
+ * require("./y")`, `{ v: require("./v") }`): each evaluates its module at
+ * that position, exactly like a bare require statement. Top-level require
+ * statements and bare require statements are collected by their own
+ * scans; a require that initializes a nested declaration keeps its
+ * lowering fence and is not an edge. */
+function inlineRequiresOf7(sf) {
+    const out = [];
+    ts.walkPreorder(sf, (n) => {
+        if (!ts.isCallExpression(n) || requireSpecOf7(n) === null)
+            return;
+        let outer = n;
+        while (outer.parent !== undefined &&
+            (ts.isParenthesizedExpression(outer.parent) ||
+                ts.isAsExpression(outer.parent) ||
+                ts.isTypeAssertion(outer.parent) ||
+                ts.isNonNullExpression(outer.parent))) {
+            outer = outer.parent;
+        }
+        const parent = outer.parent;
+        if (parent !== undefined && ts.isExpressionStatement(parent))
+            return;
+        if (parent !== undefined && ts.isVariableDeclaration(parent) && parent.initializer === outer)
+            return;
+        out.push(n);
+    });
+    return out;
+}
 function stripRequireCasts7(expr) {
     let cur = expr;
     while (ts.isParenthesizedExpression(cur) ||
@@ -1117,7 +1778,7 @@ function stripRequireCasts7(expr) {
 function isCreateRequireImport7(program, ident) {
     const checker = program.getTypeChecker();
     const symbol = checker.getSymbolAtLocation(ident);
-    const decl = symbol ? checker.declarationsOf(symbol)[0] : undefined;
+    const decl = symbol ? symbol.declarations[0] : undefined;
     if (decl === undefined || !ts.isImportSpecifier(decl))
         return false;
     const importDecl = decl.parent?.parent?.parent;
@@ -1129,11 +1790,12 @@ function isCreateRequireImport7(program, ident) {
     }
     if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {
         const target = checker.getAliasedSymbol(symbol);
-        const targetDecl = checker.declarationsOf(target)[0];
-        if (targetDecl !== undefined && targetDecl.getSourceFile().isDeclarationFile) {
+        const targetDecl = target.declarations[0];
+        if (targetDecl !== undefined && ts.getSourceFileOfNode(targetDecl).isDeclarationFile) {
             for (let p = targetDecl.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
                 if (ts.isModuleDeclaration(p) && ts.isStringLiteral(p.name)) {
-                    return (canonicalBuiltinModule(p.name.text) === "module" && target.name === "createRequire");
+                    return (canonicalBuiltinModule(p.name.text) === "module" &&
+                        ts.symbolName(target) === "createRequire");
                 }
             }
         }
@@ -1147,9 +1809,7 @@ export function isCreateRequireBinding7(program, callee) {
     const checker = program.getTypeChecker();
     const symbol = checker.getSymbolAtLocation(callee);
     const decl = symbol
-        ? checker
-            .declarationsOf(symbol)
-            .find((d) => ts.isVariableDeclaration(d))
+        ? symbol.declarations.find((d) => ts.isVariableDeclaration(d))
         : undefined;
     if (decl === undefined ||
         decl.initializer === undefined ||
@@ -1182,8 +1842,8 @@ function staticCreateRequireUse7(expr) {
     return (ts.isCallExpression(call) &&
         call.expression === use &&
         !call.questionDotToken &&
-        call.arguments.length === 1 &&
-        ts.isStringLiteralLike(call.arguments[0]));
+        call.arguments.nodes.length === 1 &&
+        ts.isStringLiteralLike(call.arguments.nodes[0]));
 }
 function stableCreateRequireBindingReason7(program, decl) {
     const cache = program.analysis.createRequireReasons;
@@ -1198,11 +1858,11 @@ function stableCreateRequireBindingReason7(program, decl) {
         }
         const checker = program.getTypeChecker();
         const symbol = checker.getSymbolAtLocation(decl.name);
-        if (!symbol || checker.declarationsOf(symbol).length !== 1)
+        if (!symbol || symbol.declarations.length !== 1)
             return "its createRequire binding is redeclared";
         if ((ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Export) !== 0)
             return "its createRequire result escapes through an exported binding";
-        const sf = decl.getSourceFile();
+        const sf = ts.getSourceFileOfNode(decl);
         const refs = identifierOccurrences7(sf, decl.name.text);
         checker.prefetchSymbolNodesExact(refs);
         for (const ref of refs) {
@@ -1217,8 +1877,8 @@ function stableCreateRequireBindingReason7(program, decl) {
                 return "its createRequire binding is reassigned, escapes, or uses a computed specifier";
             }
         }
-        const preceding = stmt.declarationList.declarations.slice(0, stmt.declarationList.declarations.indexOf(decl));
-        if (bindingEarlyUse7(program, sf, sf.statements.indexOf(stmt), decl, preceding) !== null) {
+        const preceding = stmt.declarationList.declarations.nodes.slice(0, stmt.declarationList.declarations.nodes.indexOf(decl));
+        if (bindingEarlyUse7(program, sf, sf.statements.nodes.indexOf(stmt), decl, preceding) !== null) {
             return "its createRequire binding can be used before initialization";
         }
         return null;
@@ -1233,10 +1893,10 @@ function isCreateRequireBaseCall7(program, expr) {
         init.questionDotToken !== undefined ||
         !ts.isIdentifier(init.expression) ||
         !isCreateRequireImport7(program, init.expression) ||
-        init.arguments.length !== 1) {
+        init.arguments.nodes.length !== 1) {
         return false;
     }
-    const base = stripRequireCasts7(init.arguments[0]);
+    const base = stripRequireCasts7(init.arguments.nodes[0]);
     if (ts.isIdentifier(base) && base.text === "__filename")
         return !sourceBinding7(program, base);
     return (ts.isPropertyAccessExpression(base) &&
@@ -1259,8 +1919,8 @@ function npmStaticModuleImportReason7(program, stmt) {
     if (!bindings || !ts.isNamedImports(bindings))
         return null;
     const checker = program.getTypeChecker();
-    const sf = stmt.getSourceFile();
-    for (const specifier of bindings.elements) {
+    const sf = ts.getSourceFileOfNode(stmt);
+    for (const specifier of bindings.elements.nodes) {
         if ((specifier.propertyName?.text ?? specifier.name.text) !== "createRequire")
             continue;
         const imported = checker.getSymbolAtLocation(specifier.name);
@@ -1335,8 +1995,8 @@ function requireCallBindingKind7(program, node) {
     const symbol = checker.getSymbolAtLocation(call.expression);
     if (symbol === undefined)
         return "ambient";
-    const decls = checker.declarationsOf(symbol);
-    if (decls.every((d) => d.getSourceFile().isDeclarationFile))
+    const decls = symbol.declarations;
+    if (decls.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile))
         return "ambient";
     return isCreateRequireBinding7(program, call.expression) ? "createRequire" : "source";
 }
@@ -1349,7 +2009,7 @@ const CJS_WRAPPER_NAMES = new Set(["require", "module", "exports", "__dirname",
 function bindingDeclaresCjsWrapper7(name) {
     if (ts.isIdentifier(name))
         return CJS_WRAPPER_NAMES.has(name.text) ? name : null;
-    for (const el of name.elements) {
+    for (const el of name.elements.nodes) {
         if (el.name === undefined)
             continue;
         const hit = bindingDeclaresCjsWrapper7(el.name);
@@ -1372,10 +2032,10 @@ function insideFunctionLike7(node) {
  * import/export forms, import.meta, top-level await/for-await, or a top-level
  * lexical declaration that would redeclare a CommonJS wrapper binding. */
 function nodeEsmSyntaxMarker7(sf) {
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         if (ts.isImportDeclaration(stmt) && !erasedTypeOnlyImport(stmt))
             return stmt;
-        if (ts.isExportDeclaration(stmt) && !stmt.isTypeOnly && !erasedTypeOnlyReexport(stmt)) {
+        if (ts.isExportDeclaration(stmt) && !stmt.isTypeOnly) {
             return stmt;
         }
         if (ts.isExportAssignment(stmt))
@@ -1386,7 +2046,7 @@ function nodeEsmSyntaxMarker7(sf) {
         }
         if (ts.isVariableStatement(stmt) &&
             (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0) {
-            for (const decl of stmt.declarationList.declarations) {
+            for (const decl of stmt.declarationList.declarations.nodes) {
                 const hit = bindingDeclaresCjsWrapper7(decl.name);
                 if (hit !== null)
                     return hit;
@@ -1479,15 +2139,15 @@ function selfImportTdzFences7(program, sf, clause, diags) {
     // The aliased declaration's TDZ horizon: the position after which reads
     // are initialized. Hoisted functions have none.
     const tdzEndOf = (aliased) => {
-        const d = checker.valueDeclarationOf(aliased) ?? checker.declarationsOf(aliased)[0];
-        if (d === undefined || d.getSourceFile() !== sf)
+        const d = aliased.valueDeclaration ?? aliased.declarations[0];
+        if (d === undefined || ts.getSourceFileOfNode(d) !== sf)
             return null;
         if (ts.isFunctionDeclaration(d))
             return null;
-        return d.getEnd();
+        return d.end;
     };
     const fence = (ref, name) => {
-        diags.push(unsupportedDiag("SC1030", { file: sf.fileName, start: ref.getStart(sf), end: ref.getEnd() }, `the self-import binding '${name}' read above its declaration (the import aliases this module's OWN binding — Node initializes it when the declaration executes, so this read throws ReferenceError; move the read below the declaration)`));
+        diags.push(unsupportedDiag("SC1030", { file: sf.fileName, start: ts.tokenStartOfNode(ref), end: ref.end }, `the self-import binding '${name}' read above its declaration (the import aliases this module's OWN binding — Node initializes it when the declaration executes, so this read throws ReferenceError; move the read below the declaration)`));
     };
     const checkNamed = (bindingName) => {
         const sym = checker.getSymbolAtLocation(bindingName);
@@ -1501,7 +2161,7 @@ function selfImportTdzFences7(program, sf, clause, diags) {
             if (ts.isIdentifier(node) &&
                 node !== bindingName &&
                 node.text === bindingName.text &&
-                node.getStart(sf) < end &&
+                ts.tokenStartOfNode(node) < end &&
                 !insideFunction(node) &&
                 checker.getSymbolAtLocation(node) === sym) {
                 fence(node, bindingName.text);
@@ -1513,7 +2173,7 @@ function selfImportTdzFences7(program, sf, clause, diags) {
     if (clause.name !== undefined)
         checkNamed(clause.name);
     if (clause.namedBindings !== undefined && ts.isNamedImports(clause.namedBindings)) {
-        for (const el of clause.namedBindings.elements) {
+        for (const el of clause.namedBindings.elements.nodes) {
             if (!el.isTypeOnly)
                 checkNamed(el.name);
         }
@@ -1534,7 +2194,7 @@ function selfImportTdzFences7(program, sf, clause, diags) {
                 const memberSym = checker.getSymbolAtLocation(node.name);
                 if (memberSym !== undefined) {
                     const end = tdzEndOf(memberSym);
-                    if (end !== null && node.getStart(sf) < end)
+                    if (end !== null && ts.tokenStartOfNode(node) < end)
                         fence(node.expression, `${nsName.text}.${node.name.text}`);
                 }
             }
@@ -1632,7 +2292,7 @@ function inTypePosition7(node) {
  * coercion of a user object) disqualifies the module's cycles. */
 function nonInertTopLevel7(program, sf) {
     const nonInert = topLevelInertness7(program);
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         const offence = nonInert(stmt);
         if (offence !== null)
             return offence;
@@ -1677,10 +2337,10 @@ function topLevelInertness7(program) {
             return false;
         if (sym.flags & ts.SymbolFlags.Alias)
             sym = checker.getAliasedSymbol(sym);
-        const decls = checker.declarationsOf(sym);
-        return decls.length > 0 && decls.every((d) => d.getSourceFile().isDeclarationFile);
+        const decls = sym.declarations;
+        return decls.length > 0 && decls.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile);
     };
-    const hasDecorator = (n) => (n.modifiers ?? []).some((m) => m.kind === ts.SyntaxKind.Decorator);
+    const hasDecorator = (n) => (n.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.Decorator);
     /** No function-like node anywhere in the subtree — arguments to builtin
      * calls must not smuggle a callback the builtin could invoke. */
     const containsFunctionLike = (n) => {
@@ -1697,14 +2357,14 @@ function topLevelInertness7(program) {
     const inertClass = (c) => {
         if (hasDecorator(c))
             return c;
-        for (const h of c.heritageClauses ?? []) {
+        for (const h of c.heritageClauses?.nodes ?? []) {
             if (h.token !== ts.SyntaxKind.ExtendsKeyword)
                 continue;
-            for (const t of h.types)
+            for (const t of h.types.nodes)
                 if (!inert(t.expression))
                     return t.expression;
         }
-        for (const m of c.members) {
+        for (const m of c.members.nodes) {
             if (ts.isClassStaticBlockDeclaration(m))
                 return m;
             if (hasDecorator(m))
@@ -1761,7 +2421,7 @@ function topLevelInertness7(program) {
             return dtsRooted(e) && inert(e.argumentExpression) && primitiveTyped(e.argumentExpression);
         }
         if (ts.isTemplateExpression(e)) {
-            return e.templateSpans.every((s) => inert(s.expression) && primitiveTyped(s.expression));
+            return e.templateSpans.nodes.every((s) => inert(s.expression) && primitiveTyped(s.expression));
         }
         if (ts.isVoidExpression(e) || ts.isTypeOfExpression(e))
             return inert(e.expression);
@@ -1785,9 +2445,9 @@ function topLevelInertness7(program) {
         if (ts.isConditionalExpression(e))
             return inert(e.condition) && inert(e.whenTrue) && inert(e.whenFalse);
         if (ts.isArrayLiteralExpression(e))
-            return e.elements.every((el) => !ts.isSpreadElement(el) && inert(el));
+            return e.elements.nodes.every((el) => !ts.isSpreadElement(el) && inert(el));
         if (ts.isObjectLiteralExpression(e)) {
-            return e.properties.every((p) => {
+            return e.properties.nodes.every((p) => {
                 if (ts.isShorthandPropertyAssignment(p))
                     return true;
                 if (!ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name))
@@ -1798,7 +2458,7 @@ function topLevelInertness7(program) {
         if (ts.isCallExpression(e) || ts.isNewExpression(e)) {
             if (!dtsRooted(e.expression) || !ts.isIdentifier(chainRoot7(e.expression)))
                 return false;
-            const args = e.arguments ?? [];
+            const args = e.arguments?.nodes ?? [];
             // A CALLABLE argument is admissible when it is itself dts-rooted:
             // a builtin-owned function value (the `promisify(fs.readFile)`
             // at every cycle member's top level) is runtime-implemented — even
@@ -1825,12 +2485,12 @@ function topLevelInertness7(program) {
             return null;
         }
         if (ts.isEnumDeclaration(stmt)) {
-            return stmt.members.find((m) => m.initializer !== undefined && !inert(m.initializer)) ?? null;
+            return (stmt.members.nodes.find((m) => m.initializer !== undefined && !inert(m.initializer)) ?? null);
         }
         if (ts.isClassDeclaration(stmt))
             return inertClass(stmt);
         if (ts.isVariableStatement(stmt)) {
-            for (const d of stmt.declarationList.declarations) {
+            for (const d of stmt.declarationList.declarations.nodes) {
                 if (!ts.isIdentifier(d.name))
                     return d.name; // patterns can invoke getters/iterators
                 if (d.initializer !== undefined && !inert(d.initializer))
@@ -1883,7 +2543,7 @@ function backEdgeUseOffence7(program, stmt, occurrences) {
         if (ts.isNamespaceImport(clause.namedBindings))
             bindingNames.push(clause.namedBindings.name);
         else
-            for (const el of clause.namedBindings.elements)
+            for (const el of clause.namedBindings.elements.nodes)
                 if (!el.isTypeOnly)
                     bindingNames.push(el.name);
     }
@@ -1948,8 +2608,8 @@ export function makeCycleAdmission(program, edgesOf) {
         }
     };
     const lineOf = (node) => {
-        const nsf = node.getSourceFile();
-        return `${nsf.fileName}:${ts.getLineAndCharacterOfPosition(nsf, node.getStart(nsf)).line + 1}`;
+        const nsf = ts.getSourceFileOfNode(node);
+        return `${nsf.fileName}:${ts.getLineAndCharacterOfPosition(nsf, ts.tokenStartOfNode(node)).line + 1}`;
     };
     // Cluster verdict memo (keyed by the component array identity): true
     // when every member is an ES module passing the inert-top-level bar.
@@ -1980,13 +2640,26 @@ export function makeCycleAdmission(program, edgesOf) {
         bindingUses.set(sf, uses);
         return uses;
     };
+    // The CommonJS cluster verdict, same keying (cjsCycleRefusal7).
+    const cjsVerdict = new Map();
     return (importer, e) => {
-        if (e.stmt === undefined)
-            return "the cycle closes through a require() edge";
+        if (e.stmt === undefined) {
+            if (!index.has(importer))
+                strongconnect(importer);
+            const comp = sccOf.get(e.dep);
+            if (comp === undefined || comp.length < 2 || !comp.includes(importer)) {
+                return "the cycle closes through a require() edge";
+            }
+            if (!cjsVerdict.has(comp))
+                cjsVerdict.set(comp, cjsCycleRefusal7(program, comp, lineOf));
+            const reason = cjsVerdict.get(comp) ?? null;
+            return reason === null ? null : `the cycle closes through a require() edge: ${reason}`;
+        }
         // Cheap per-edge admission: nothing readable binds through the edge.
         if (ts.isImportDeclaration(e.stmt)) {
             const clause = e.stmt.importClause;
             if (clause === undefined ||
+                typeOnlyNamedImport(e.stmt) ||
                 (clause.name === undefined &&
                     (clause.namedBindings === undefined ||
                         (ts.isNamespaceImport(clause.namedBindings) &&
@@ -2022,6 +2695,364 @@ export function makeCycleAdmission(program, edgesOf) {
         return exactVerdict.get(comp) ?? null;
     };
 }
+/** The reason a strongly-connected cluster of CommonJS modules cannot be
+ * initialized exactly through its require() cycle, or null when it can.
+ * Node answers a require of a module that is still evaluating with that
+ * module's exports object as it stands, while the compiled bindings alias
+ * the exporter's final declarations. The two agree when:
+ *  - every member settles its exports before anything can enter the
+ *    cycle: all of its export statements come before its first top-level
+ *    statement that can run another module's code (a require, or anything
+ *    but literals, plain reads, function and class values, and
+ *    standard-library globals called with literal arguments), and every
+ *    other use of its export object is a plain member read; and
+ *  - no member's top-level code can reach its binding of another member,
+ *    so no member runs another member's code while the cluster is still
+ *    initializing. Each module then initializes exactly as it would
+ *    outside the cycle, and its own require bindings keep the acyclic
+ *    analysis (requireEarlyReference).
+ * Other cycles keep the SC1016 fence. */
+function cjsCycleRefusal7(program, comp, lineOf) {
+    const members = new Set(comp);
+    const builtinRoot = (e) => {
+        while (ts.isPropertyAccessExpression(e))
+            e = e.expression;
+        return ts.isIdentifier(e) && !sourceBinding7(program, e);
+    };
+    const literal = (e) => ts.isStringLiteralLike(e) ||
+        ts.isNumericLiteral(e) ||
+        ts.isRegularExpressionLiteral(e) ||
+        e.kind === ts.SyntaxKind.TrueKeyword ||
+        e.kind === ts.SyntaxKind.FalseKeyword ||
+        e.kind === ts.SyntaxKind.NullKeyword;
+    /** An expression whose evaluation runs no user code and requires
+     * nothing: literals, plain reads, function and class values, literal
+     * containers of those, and standard-library globals called with
+     * literal arguments. */
+    const inertExpr = (e) => {
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (literal(e) || ts.isIdentifier(e))
+            return true;
+        if (ts.isFunctionExpression(e) || ts.isArrowFunction(e))
+            return true;
+        if (ts.isClassExpression(e))
+            return classSyncParts7(e).every(inertPart);
+        if (ts.isObjectLiteralExpression(e)) {
+            return e.properties.nodes.every((p) => ts.isShorthandPropertyAssignment(p)
+                ? true
+                : ts.isPropertyAssignment(p)
+                    ? !ts.isComputedPropertyName(p.name) && inertExpr(p.initializer)
+                    : (ts.isMethodDeclaration(p) ||
+                        ts.isGetAccessorDeclaration(p) ||
+                        ts.isSetAccessorDeclaration(p)) &&
+                        !ts.isComputedPropertyName(p.name));
+        }
+        if (ts.isArrayLiteralExpression(e)) {
+            return e.elements.nodes.every((el) => !ts.isSpreadElement(el) && inertExpr(el));
+        }
+        if (ts.isPropertyAccessExpression(e))
+            return builtinRoot(e);
+        if (ts.isVoidExpression(e))
+            return literal(e.expression);
+        if (ts.isCallExpression(e) || ts.isNewExpression(e)) {
+            return (requireSpecOf7(e) === null &&
+                builtinRoot(e.expression) &&
+                (e.arguments?.nodes ?? []).every(literal));
+        }
+        return false;
+    };
+    const inertPart = (part) => {
+        if (ts.isHeritageClause(part))
+            return part.types.nodes.every((t) => inertExpr(t.expression));
+        if (ts.isComputedPropertyName(part))
+            return inertExpr(part.expression);
+        return ts.isExpression(part) && inertExpr(part);
+    };
+    const exportObject = (e) => (ts.isIdentifier(e) && e.text === "exports" && !sourceBinding7(program, e)) ||
+        (isModuleExportsAccess(e) &&
+            ts.isIdentifier(e.expression) &&
+            !sourceBinding7(program, e.expression));
+    /** A top-level statement that only publishes inert values. */
+    const exportStatement = (stmt) => {
+        if (!ts.isExpressionStatement(stmt))
+            return false;
+        if (isEsModuleStamp(stmt.expression))
+            return true;
+        const cjs = cjsExportAssignmentOf(stmt);
+        if (cjs !== null) {
+            let value = cjs.expr;
+            while (ts.isBinaryExpression(value) &&
+                value.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                const left = value.left;
+                if (!isModuleExportsAccess(left) &&
+                    !(ts.isPropertyAccessExpression(left) && exportObject(left.expression)))
+                    return false;
+                value = value.right;
+            }
+            return inertExpr(value);
+        }
+        const call = stmt.expression;
+        return (ts.isCallExpression(call) &&
+            ts.isPropertyAccessExpression(call.expression) &&
+            ts.isIdentifier(call.expression.expression) &&
+            call.expression.expression.text === "Object" &&
+            !sourceBinding7(program, call.expression.expression) &&
+            call.expression.name.text === "defineProperty" &&
+            call.arguments.nodes.length === 3 &&
+            exportObject(call.arguments.nodes[0]) &&
+            ts.isStringLiteralLike(call.arguments.nodes[1]) &&
+            inertExpr(call.arguments.nodes[2]));
+    };
+    for (const m of comp) {
+        if (!isCjsJsFile7(m, program)) {
+            return `${m.fileName} is not a CommonJS module — require cycles are admitted between CommonJS modules only`;
+        }
+        const stmts = m.statements.nodes;
+        // The first statement that can run another module's code.
+        let firstEntry = stmts.length;
+        for (let i = 0; i < stmts.length; i++) {
+            const st = stmts[i];
+            const inert = ts.isFunctionDeclaration(st) ||
+                ts.isEmptyStatement(st) ||
+                (ts.isExpressionStatement(st) && ts.isStringLiteral(st.expression)) ||
+                (ts.isClassDeclaration(st) && classSyncParts7(st).every(inertPart)) ||
+                (ts.isVariableStatement(st) &&
+                    st.declarationList.declarations.nodes.every((d) => ts.isIdentifier(d.name) && (d.initializer === undefined || inertExpr(d.initializer)))) ||
+                exportStatement(st);
+            if (!inert) {
+                firstEntry = i;
+                break;
+            }
+        }
+        // Every other use of the export object must be a plain member read:
+        // anything else can change what a module of the cycle observes.
+        let stray = null;
+        const settled = new Set(stmts.slice(0, firstEntry).filter(exportStatement));
+        // A bundler export table the rewrite certified (npmStaticLiveExportTable)
+        // stands for the live getter object the original installed before its
+        // first require: the tail table settles as if it ran there.
+        const tail = stmts[stmts.length - 1];
+        if (tail !== undefined &&
+            npmStaticLiveExportTable(m.fileName) &&
+            cjsExportAssignmentOf(tail)?.kind === "table")
+            settled.add(tail);
+        ts.walkPreorder(m, (n) => {
+            if (stray !== null)
+                return "stop";
+            if (ts.isStatement(n) && settled.has(n))
+                return "skip";
+            let use = null;
+            if (n.kind === ts.SyntaxKind.ThisKeyword) {
+                let moduleThis = true;
+                for (let p = n.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
+                    if ((ts.isFunctionLike(p) && !ts.isArrowFunction(p)) ||
+                        ts.isClassDeclaration(p) ||
+                        ts.isClassExpression(p)) {
+                        moduleThis = false;
+                        break;
+                    }
+                }
+                if (moduleThis)
+                    use = n;
+            }
+            else if (ts.isIdentifier(n) &&
+                (n.text === "exports" || n.text === "module") &&
+                !(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n) &&
+                !sourceBinding7(program, n)) {
+                if (n.text === "exports")
+                    use = n;
+                else if (!ts.isPropertyAccessExpression(n.parent) || n.parent.expression !== n)
+                    stray = n;
+                else if (n.parent.name.text === "exports")
+                    use = n.parent;
+            }
+            if (use === null)
+                return undefined;
+            const parent = use.parent;
+            const read = ts.isPropertyAccessExpression(parent) &&
+                parent.expression === use &&
+                !(ts.isBinaryExpression(parent.parent) &&
+                    parent.parent.left === parent &&
+                    parent.parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                    parent.parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment) &&
+                !(ts.isCallExpression(parent.parent) && parent.parent.expression === parent) &&
+                !ts.isDeleteExpression(parent.parent);
+            if (!read)
+                stray = use;
+            return undefined;
+        });
+        if (stray !== null) {
+            return `${m.fileName} uses its exports at ${lineOf(stray)} outside the export statements that precede its first require, so a module of the cycle can observe them before they settle`;
+        }
+        // Bindings of other members must stay unreachable from top-level code.
+        for (const st of stmts) {
+            for (const req of requiresOf7(st)) {
+                if (req.decl === null)
+                    continue;
+                const dep = resolveImport7(program, m, req.spec, "require");
+                if (dep === null || !members.has(dep))
+                    continue;
+                const reached = requireBindingEarlyUse7(program, m, stmts.length, req.decl, [], (id) => functionExportRead7(id, dep));
+                if (reached !== null) {
+                    return `the top-level code of ${m.fileName} can use its binding '${reached.text}' of a module of the cycle (${lineOf(reached)}) while the cycle initializes`;
+                }
+            }
+        }
+    }
+    return null;
+}
+/** True when `use` initializes a top-level const whose every other
+ * reference is a value of an export statement (`module.exports = { … }`
+ * or `exports.n = …`). */
+function publishedAlias7(use, decl) {
+    if (decl === undefined ||
+        !ts.isVariableDeclaration(decl) ||
+        decl.initializer !== use ||
+        !ts.isIdentifier(decl.name))
+        return false;
+    const list = decl.parent;
+    const stmt = list?.parent;
+    const sf = stmt?.parent;
+    if (list === undefined ||
+        (list.flags & ts.NodeFlags.Const) === 0 ||
+        stmt === undefined ||
+        !ts.isVariableStatement(stmt) ||
+        sf === undefined ||
+        !ts.isSourceFile(sf))
+        return false;
+    const alias = decl.name;
+    const published = new Set();
+    for (const st of sf.statements.nodes) {
+        const cjs = cjsExportAssignmentOf(st);
+        if (cjs === null)
+            continue;
+        if (cjs.kind === "member")
+            published.add(cjs.value);
+        else if (cjs.obj !== null) {
+            for (const p of cjs.obj.properties.nodes) {
+                if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name))
+                    published.add(p.initializer);
+                else if (ts.isShorthandPropertyAssignment(p))
+                    published.add(p.name);
+            }
+        }
+    }
+    let kept = false;
+    ts.walkPreorder(sf, (n) => {
+        if (kept)
+            return "stop";
+        if (!ts.isIdentifier(n) || n === alias || n.text !== alias.text)
+            return undefined;
+        const p = n.parent;
+        if (p !== undefined &&
+            ((ts.isPropertyAccessExpression(p) && p.name === n) ||
+                (ts.isPropertyAssignment(p) && p.name === n)))
+            return undefined;
+        if (!published.has(n))
+            kept = true;
+        return undefined;
+    });
+    return !kept;
+}
+/** True for a plain read `binding.name` (not a call, not a write, not a
+ * value that is stored or passed on) of the cycle member `dep` whose
+ * export `name` is a top-level function declaration nothing reassigns.
+ * Every member settles its exports before entering the cycle, so Node
+ * reads that same function whenever the read runs, and the compiled read
+ * resolves to the declaration itself. */
+function functionExportRead7(id, dep) {
+    const access = id.parent;
+    if (!ts.isPropertyAccessExpression(access) || access.expression !== id)
+        return false;
+    // The value the read yields: through parentheses and the right operand
+    // of a comma, so `(0, binding.name)(...)` is the call it spells.
+    let use = access;
+    for (;;) {
+        const p = use.parent;
+        if (ts.isParenthesizedExpression(p))
+            use = p;
+        else if (ts.isBinaryExpression(p) &&
+            p.operatorToken.kind === ts.SyntaxKind.CommaToken &&
+            p.right === use)
+            use = p;
+        else
+            break;
+    }
+    const parent = use.parent;
+    // Only a use that neither runs the function nor keeps it is a read: a
+    // stored alias (`const f = binding.name`, `{ f: binding.name }`) or an
+    // argument can be called while the cycle initializes. A top-level const
+    // that only publishes it (`module.exports = { name: f }`, the static
+    // rewrite's re-export spelling) runs nothing: a module that reads the
+    // export back checks that read itself.
+    const observes = publishedAlias7(use, parent) ||
+        ts.isExpressionStatement(parent) ||
+        ts.isTypeOfExpression(parent) ||
+        ts.isVoidExpression(parent) ||
+        (ts.isPrefixUnaryExpression(parent) && parent.operator === ts.SyntaxKind.ExclamationToken) ||
+        (ts.isBinaryExpression(parent) &&
+            (parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+                parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+                parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
+                parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken)) ||
+        ((ts.isIfStatement(parent) || ts.isWhileStatement(parent) || ts.isDoStatement(parent)) &&
+            parent.expression === use) ||
+        (ts.isConditionalExpression(parent) && parent.condition === use);
+    if (!observes)
+        return false;
+    const name = access.name.text;
+    // The exported value's identifier: a table entry or a member export.
+    const values = [];
+    for (const stmt of dep.statements.nodes) {
+        if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression))
+            continue;
+        const e = stmt.expression;
+        if (e.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+            continue;
+        if (isModuleExportsAccess(e.left)) {
+            if (!ts.isObjectLiteralExpression(e.right))
+                return false;
+            for (const p of e.right.properties.nodes) {
+                if (ts.isSpreadAssignment(p))
+                    return false;
+                if (ts.isShorthandPropertyAssignment(p) && p.name.text === name)
+                    values.push(p.name);
+                else if (ts.isPropertyAssignment(p) &&
+                    (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
+                    p.name.text === name)
+                    values.push(p.initializer);
+            }
+        }
+        else if (ts.isPropertyAccessExpression(e.left) &&
+            e.left.name.text === name &&
+            ((ts.isIdentifier(e.left.expression) && e.left.expression.text === "exports") ||
+                isModuleExportsAccess(e.left.expression))) {
+            values.push(e.right);
+        }
+    }
+    const value = values.length === 1 ? values[0] : null;
+    if (value === null || !ts.isIdentifier(value))
+        return false;
+    const fnName = value.text;
+    if (!dep.statements.nodes.some((st) => ts.isFunctionDeclaration(st) && st.name?.text === fnName && st.body !== undefined))
+        return false;
+    let rebound = false;
+    ts.walkPreorder(dep, (n) => {
+        if (rebound)
+            return "stop";
+        if ((ts.isBinaryExpression(n) &&
+            ts.isIdentifier(n.left) &&
+            n.left.text === fnName &&
+            n.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+            n.operatorToken.kind <= ts.SyntaxKind.LastAssignment) ||
+            (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name) && n.name.text === fnName) ||
+            (ts.isFunctionDeclaration(n) && n.name?.text === fnName && !ts.isSourceFile(n.parent)))
+            rebound = true;
+        return undefined;
+    });
+    return !rebound;
+}
 /* ── exact cyclic initialization ─────────────────────────────────────────
  * Cycles that fail the declaration-only rule still evaluate exactly like
  * Node when their shape is representable: the guarded %init calls already
@@ -2065,7 +3096,7 @@ function exactCycleRefusal7(program, comp, lineOf) {
         const spec = stmt.moduleSpecifier;
         if (spec === undefined || !ts.isStringLiteral(spec))
             return null;
-        const sf = stmt.getSourceFile();
+        const sf = ts.getSourceFileOfNode(stmt);
         return resolveImport7(program, sf, spec.text) ?? npmStaticDepSf7(program, sf, spec.text);
     };
     for (const m of comp) {
@@ -2075,7 +3106,7 @@ function exactCycleRefusal7(program, comp, lineOf) {
         if (hasTopLevelAwait7(m)) {
             return `${m.fileName} uses top-level await inside the cycle`;
         }
-        for (const stmt of m.statements) {
+        for (const stmt of m.statements.nodes) {
             if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
                 return `the default export expression at ${lineOf(stmt)} has no initialization state inside the cycle`;
             }
@@ -2223,7 +3254,7 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
         const names = new Set();
         let dirty = !known;
         evaluation.forEach((m, rank) => {
-            for (const stmt of m.statements) {
+            for (const stmt of m.statements.nodes) {
                 const offence = nonInert(stmt);
                 const exposed = dirty || offence !== null;
                 const declared = [];
@@ -2232,7 +3263,7 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                         ts.ModifierFlags.Ambient) ===
                         0) {
                     const lexical = (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
-                    for (const d of stmt.declarationList.declarations) {
+                    for (const d of stmt.declarationList.declarations.nodes) {
                         for (const name of boundNames7(d.name)) {
                             declared.push({ name, kind: lexical ? "lexical" : "var" });
                         }
@@ -2252,8 +3283,8 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                         module: m,
                         exposed,
                         rank,
-                        start: stmt.getStart(m),
-                        end: stmt.getEnd(),
+                        start: ts.tokenStartOfNode(stmt),
+                        end: stmt.end,
                         reference: null,
                         folded: null,
                     });
@@ -2305,14 +3336,14 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                 // A class body names its own inner binding, initialized throughout.
                 if (c.kind === "class" &&
                     sf === c.module &&
-                    ref.getStart(sf) >= c.start &&
-                    ref.getEnd() <= c.end)
+                    ts.tokenStartOfNode(ref) >= c.start &&
+                    ref.end <= c.end)
                     continue;
                 let early;
                 if (inDeferredPosition7(ref))
                     early = c.exposed;
                 else if (sf === c.module)
-                    early = ref.getStart(sf) < c.start;
+                    early = ts.tokenStartOfNode(ref) < c.start;
                 else if (!memberSet.has(sf) || !rankOf.has(sf))
                     early = false;
                 else
@@ -2406,7 +3437,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
             immediate.set(e, classSyncParts7(e));
         }
         else if (ts.isObjectLiteralExpression(e)) {
-            for (const p of e.properties) {
+            for (const p of e.properties.nodes) {
                 if (ts.isMethodDeclaration(p) ||
                     ts.isGetAccessorDeclaration(p) ||
                     ts.isSetAccessorDeclaration(p)) {
@@ -2424,14 +3455,14 @@ function moduleEarlyBindingsOf7(program, sf, order) {
             }
         }
         else if (ts.isArrayLiteralExpression(e)) {
-            for (const el of e.elements)
+            for (const el of e.elements.nodes)
                 if (!ts.isSpreadElement(el))
                     storedIn(el, units);
         }
         else if (ts.isCallExpression(e)) {
             // `const f = wrap(callback)` where wrap only returns closures over
             // the callback: it runs when the stored result is called.
-            e.arguments.forEach((arg, index) => {
+            e.arguments.nodes.forEach((arg, index) => {
                 let fn = arg;
                 while (ts.isParenthesizedExpression(fn))
                     fn = fn.expression;
@@ -2441,7 +3472,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
             });
         }
     };
-    sf.statements.forEach((stmt, index) => {
+    sf.statements.nodes.forEach((stmt, index) => {
         if (ambient(stmt))
             return;
         if (ts.isFunctionDeclaration(stmt) && stmt.name !== undefined && stmt.body !== undefined) {
@@ -2449,12 +3480,12 @@ function moduleEarlyBindingsOf7(program, sf, order) {
         }
         else if (ts.isClassDeclaration(stmt) && stmt.name !== undefined) {
             store(stmt.name, [stmt]);
-            candidates.push({ name: stmt.name, index, start: stmt.getStart(sf), cls: stmt });
+            candidates.push({ name: stmt.name, index, start: ts.tokenStartOfNode(stmt), cls: stmt });
             candidateNames.add(stmt.name.text);
         }
         else if (ts.isVariableStatement(stmt)) {
             const lexical = (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
-            for (const d of stmt.declarationList.declarations) {
+            for (const d of stmt.declarationList.declarations.nodes) {
                 if (ts.isIdentifier(d.name) && d.initializer !== undefined) {
                     const units = [];
                     storedIn(d.initializer, units);
@@ -2463,7 +3494,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
                 if (!lexical)
                     continue;
                 for (const name of boundNames7(d.name)) {
-                    candidates.push({ name, index, start: stmt.getStart(sf) });
+                    candidates.push({ name, index, start: ts.tokenStartOfNode(stmt) });
                     candidateNames.add(name.text);
                 }
             }
@@ -2506,7 +3537,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
             if (ts.isArrowFunction(e) || ts.isFunctionExpression(e))
                 stored.add(e);
             else if (ts.isObjectLiteralExpression(e)) {
-                for (const p of e.properties) {
+                for (const p of e.properties.nodes) {
                     if (ts.isMethodDeclaration(p))
                         stored.add(p);
                     else if (ts.isPropertyAssignment(p))
@@ -2517,7 +3548,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
         ts.walkPreorder(sf, (node) => {
             if ((ts.isCallExpression(node) || ts.isNewExpression(node)) &&
                 laterJobCallee7(checker, node.expression)) {
-                for (const arg of node.arguments ?? [])
+                for (const arg of node.arguments?.nodes ?? [])
                     callbacks(arg);
             }
             return undefined;
@@ -2569,8 +3600,8 @@ function moduleEarlyBindingsOf7(program, sf, order) {
             if (c !== undefined &&
                 node !== c.name &&
                 !reachedRefs.has(symbol) &&
-                !(c.cls !== undefined && node.getStart(sf) >= c.cls.pos && node.end <= c.cls.end)) {
-                if (inDeferredPosition7(node) || node.getStart(sf) < c.start)
+                !(c.cls !== undefined && ts.tokenStartOfNode(node) >= c.cls.pos && node.end <= c.cls.end)) {
+                if (inDeferredPosition7(node) || ts.tokenStartOfNode(node) < c.start)
                     reachedRefs.set(symbol, node);
             }
             for (const unit of unitsBySymbol.get(symbol) ?? []) {
@@ -2591,8 +3622,8 @@ function moduleEarlyBindingsOf7(program, sf, order) {
     let next = 0;
     const report = (declaration) => {
         while (next < candidates.length &&
-            candidates[next].name.getStart(sf) >= declaration.getStart(sf) &&
-            candidates[next].name.getEnd() <= declaration.getEnd()) {
+            ts.tokenStartOfNode(candidates[next].name) >= ts.tokenStartOfNode(declaration) &&
+            candidates[next].name.end <= declaration.end) {
             const c = candidates[next++];
             const symbol = checker.getSymbolAtLocation(c.name);
             const reference = symbol === undefined ? undefined : reachedRefs.get(symbol);
@@ -2608,7 +3639,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
             });
         }
     };
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         if (ts.isClassDeclaration(stmt)) {
             // The binding initializes once the class definition, static
             // initializers included, has run.
@@ -2620,7 +3651,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
         else if (ts.isVariableStatement(stmt)) {
             // Declarators run in order: a later declarator's initializer cannot
             // observe an earlier binding before it was initialized.
-            for (const d of stmt.declarationList.declarations) {
+            for (const d of stmt.declarationList.declarations.nodes) {
                 visit(d);
                 drain();
                 report(d);
@@ -2650,11 +3681,11 @@ function returnsOnlyClosuresOver7(checker, callee, index) {
     if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
     }
-    const decls = symbol === undefined ? [] : checker.declarationsOf(symbol);
+    const decls = symbol === undefined ? [] : symbol.declarations;
     if (decls.length !== 1)
         return false;
     const decl = decls[0];
-    if (decl.getSourceFile().isDeclarationFile)
+    if (ts.getSourceFileOfNode(decl).isDeclarationFile)
         return false;
     let fn;
     if (ts.isFunctionDeclaration(decl))
@@ -2670,12 +3701,12 @@ function returnsOnlyClosuresOver7(checker, callee, index) {
         return false;
     const like = fn;
     const body = like.body;
-    const param = like.parameters[index];
+    const param = like.parameters.nodes[index];
     if (body === undefined || !ts.isBlock(body) || param === undefined)
         return false;
     if (!ts.isIdentifier(param.name) || param.dotDotDotToken !== undefined)
         return false;
-    if (like.parameters.slice(0, index).some((p) => p.dotDotDotToken !== undefined))
+    if (like.parameters.nodes.slice(0, index).some((p) => p.dotDotDotToken !== undefined))
         return false;
     const paramName = param.name.text;
     let deferred = true;
@@ -2723,9 +3754,9 @@ function returnsOnlyClosuresOver7(checker, callee, index) {
  * initializers and static blocks. Methods and instance fields wait for a
  * call or a construction. */
 function classSyncParts7(c) {
-    const decorators = (n) => (n.modifiers ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
-    const parts = [...decorators(c), ...(c.heritageClauses ?? [])];
-    for (const m of c.members) {
+    const decorators = (n) => (n.modifiers?.nodes ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
+    const parts = [...decorators(c), ...(c.heritageClauses?.nodes ?? [])];
+    for (const m of c.members.nodes) {
         parts.push(...decorators(m));
         const memberName = m.name;
         if (memberName !== undefined && ts.isComputedPropertyName(memberName))
@@ -2784,15 +3815,15 @@ function laterJobCallee7(checker, callee) {
     }
     if (symbol === undefined)
         return false;
-    const decls = checker.declarationsOf(symbol);
-    if (decls.length === 0 || !decls.every((d) => d.getSourceFile().isDeclarationFile))
+    const decls = symbol.declarations;
+    if (decls.length === 0 || !decls.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile))
         return false;
     if (LATER_JOB_BUILTINS7.has(name.text))
         return true;
     // The JavaScript standard library's callbacks mostly run synchronously;
     // package declarations describe user code.
     return decls.every((d) => {
-        const file = d.getSourceFile().fileName;
+        const file = ts.getSourceFileOfNode(d).fileName;
         return isNodeTypesPath(file) || file === fallbackDtsPath();
     });
 }
@@ -2855,7 +3886,7 @@ function boundNames7(name) {
     if (ts.isIdentifier(name))
         return [name];
     const out = [];
-    for (const el of name.elements) {
+    for (const el of name.elements.nodes) {
         if (ts.isOmittedExpression(el) || el.name === undefined)
             continue;
         out.push(...boundNames7(el.name));
@@ -2870,7 +3901,7 @@ function typeOnlyNamespace7(decl) {
         body = body.body;
     if (body === undefined || !ts.isModuleBlock(body))
         return true;
-    return body.statements.every((s) => ts.isInterfaceDeclaration(s) ||
+    return body.statements.nodes.every((s) => ts.isInterfaceDeclaration(s) ||
         ts.isTypeAliasDeclaration(s) ||
         (ts.isModuleDeclaration(s) && typeOnlyNamespace7(s)));
 }
@@ -2891,6 +3922,13 @@ function resolveNpmImport7(fromFileName, specifier, resolutionKind = "import") {
     if (isRelativeSpecifier(specifier) || specifier.startsWith("node:")) {
         return null;
     }
+    // Node resolves a bare core-module name (`string_decoder`, `events`,
+    // `fs/promises`) to the builtin before it looks in node_modules, so an
+    // installed npm package of the same name never answers it. Prefix-only
+    // builtins (`node:test`) are listed with their prefix, so a bare `test`
+    // still names the package.
+    if (nodeBuiltinNames.has(specifier))
+        return null;
     // --provenance-sources: a registered specifier is NOT an npm import —
     // its attested source compiles as program modules (resolveProjectModule
     if (provenanceEntryFor(specifier) !== null)
@@ -2917,18 +3955,12 @@ function resolveNpmImport7(fromFileName, specifier, resolutionKind = "import") {
     };
 }
 function locOf7(node) {
-    const sf = node.getSourceFile();
-    return { file: sf.fileName, start: node.getStart(sf), end: node.getEnd() };
+    const sf = ts.getSourceFileOfNode(node);
+    return { file: sf.fileName, start: ts.tokenStartOfNode(node), end: node.end };
 }
-/** The PROGRAM source file an opted-in --npm-static package's resolved
- * entry maps to, or null with the package marked an offender (resolution
- * still answering declarations, or the file missing from the type-checked
- * program — a path-identity mismatch between the two resolvers). */
-function npmStaticProgramDep(program, packageName, resolvedFile) {
-    if (!isJsSourceFileName(resolvedFile)) {
-        reportNpmStaticOffender(packageName, `its import resolves to '${resolvedFile}', not to runtime JavaScript`);
-        return null;
-    }
+/** The program file holding an opted-in package's resolved runtime JS:
+ * the file itself, or its same-stem TypeScript twin. */
+function npmStaticProgramFile(program, resolvedFile) {
     let dep = program.getSourceFile(resolvedFile) ?? null;
     if (dep === null) {
         // A workspace-linked package shipping its .ts SOURCE beside the
@@ -2942,6 +3974,18 @@ function npmStaticProgramDep(program, packageName, resolvedFile) {
                 break;
         }
     }
+    return dep;
+}
+/** The PROGRAM source file an opted-in --npm-static package's resolved
+ * entry maps to, or null with the package marked an offender (resolution
+ * still answering declarations, or the file missing from the type-checked
+ * program — a path-identity mismatch between the two resolvers). */
+function npmStaticProgramDep(program, packageName, resolvedFile) {
+    if (!isJsSourceFileName(resolvedFile)) {
+        reportNpmStaticOffender(packageName, `its import resolves to '${resolvedFile}', not to runtime JavaScript`);
+        return null;
+    }
+    const dep = npmStaticProgramFile(program, resolvedFile);
     if (dep === null) {
         reportNpmStaticOffender(packageName, `its entry '${resolvedFile}' did not join the type-checked program`);
         return null;
@@ -3064,7 +4108,7 @@ function preflight7(load) {
             names = new Set();
             builtinNamespaceNames.set(d.fileName, names);
             const sf = p.getSourceFile(d.fileName);
-            for (const stmt of sf?.statements ?? []) {
+            for (const stmt of sf?.statements?.nodes ?? []) {
                 if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
                     continue;
                 if (canonicalBuiltinModule(stmt.moduleSpecifier.text) === null)
@@ -3128,6 +4172,17 @@ function preflight7(load) {
             : spec.split("/")[0];
         return isWorkspacePackageName(prefix);
     };
+    // A JavaScript file that TypeScript checks keeps the type errors that
+    // protect its JSDoc types: a value of another type reaching a typed slot,
+    // a call with the wrong arity, and a subclass member that does not
+    // match its base.
+    const projectCheckJs = load.typeWorld?.projectCheckJs ?? false;
+    const enforcedInCheckedJs = (p, d) => {
+        if (!CHECKED_JS_ENFORCED_CODES.has(d.code) || d.fileName === undefined)
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        return sf !== undefined && isCheckedJsSourceFile(sf, projectCheckJs);
+    };
     const errorsOf = (p) => {
         const all = ts.getPreEmitDiagnostics(p);
         // First pass: every comment-side 2300's (file, name) — the partners
@@ -3143,7 +4198,7 @@ function preflight7(load) {
                 commentDup.add(`${d.fileName}:${sf.text.slice(d.pos, d.end)}`);
         }
         return all.filter((d) => d.category === ts.DiagnosticCategory.Error &&
-            !suppressedJsStrictness7(d) &&
+            (!suppressedJsStrictness7(d) || enforcedInCheckedJs(p, d)) &&
             !npmStaticFileSuppressed(d) &&
             !nodeModulesJsSuppressed(d) &&
             !namespaceCalleeSuppressed(p, d) &&
@@ -3185,14 +4240,23 @@ function preflight7(load) {
             entryPackageFile(sf.fileName) ||
             npmStaticPackageOfPath(sf.fileName) !== null) &&
         !unselectedPackageJsFile(sf.fileName));
+    // Files reached only through `import type` / `export type … from` are
+    // checker input, never program modules: Node does not load them, so
+    // their imports and syntax must not fence the program.
+    const resolveRuntimeEdge = (sf, spec, resolutionKind) => resolveImport7(program, sf, spec, resolutionKind) ??
+        npmStaticDepSf7(program, sf, spec, resolutionKind);
+    const typeOnlyFiles = typeOnlyReachedFiles(program, entry, programFiles, () => [
+        ...forkTargetPaths(program, program.getImplementationSourceFiles()),
+        ...workerTargetPaths(program, program.getImplementationSourceFiles()),
+    ], resolveRuntimeEdge);
+    const runtimeFiles = typeOnlyFiles.size === 0 ? programFiles : programFiles.filter((sf) => !typeOnlyFiles.has(sf));
     const userFiles = npmStaticActive()
-        ? planNpmStaticReexports(program, entry, programFiles, [
+        ? planNpmStaticReexports(program, entry, runtimeFiles, [
             ...createRequireProgramRoots7(program),
             ...forkTargetPaths(program, program.getImplementationSourceFiles()),
             ...workerTargetPaths(program, program.getImplementationSourceFiles()),
-        ], (sf, spec, resolutionKind) => resolveImport7(program, sf, spec, resolutionKind) ??
-            npmStaticDepSf7(program, sf, spec, resolutionKind))
-        : programFiles;
+        ], resolveRuntimeEdge)
+        : runtimeFiles;
     program.getTypeChecker().prefetchSourceFileStructures(userFiles);
     // Unselected node_modules JS is not native program source even when
     // maxNodeModuleJsDepth pulled it into the checker (nodeModulesJsSuppressed).
@@ -3229,7 +4293,7 @@ function preflight7(load) {
         if (ambientModuleDecls === null) {
             ambientModuleDecls = { names: new Set(), patterns: [] };
             for (const f of program.getSourceFiles()) {
-                for (const s of f.statements) {
+                for (const s of f.statements.nodes) {
                     if (!ts.isModuleDeclaration(s) || !ts.isStringLiteral(s.name))
                         continue;
                     const name = s.name.text;
@@ -3270,7 +4334,7 @@ function preflight7(load) {
         edges.set(sf, deps);
         refusals.set(sf, []);
         depPositions.set(sf, []);
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (ts.isImportEqualsDeclaration(stmt)) {
                 // The ENTITY form (`import a = A`, `import x = N.y`) is namespace
                 // alias plumbing — the lowerer resolves references through it and
@@ -3300,7 +4364,7 @@ function preflight7(load) {
                 continue;
             }
             if (ts.isExportDeclaration(stmt)) {
-                if (stmt.isTypeOnly || erasedTypeOnlyReexport(stmt) || isPrunedNpmReexport(program, stmt))
+                if (stmt.isTypeOnly || isPrunedNpmReexport(program, stmt))
                     continue;
                 if (!stmt.moduleSpecifier)
                     continue;
@@ -3353,7 +4417,7 @@ function preflight7(load) {
                 }
                 if (reDep && !reDep.fileName.endsWith(".json")) {
                     deps.push({ dep: reDep, stmt });
-                    depPositions.get(sf).push({ dep: reDep, pos: stmt.getStart(sf) });
+                    depPositions.get(sf).push({ dep: reDep, pos: ts.tokenStartOfNode(stmt) });
                 }
                 continue;
             }
@@ -3400,7 +4464,7 @@ function preflight7(load) {
                 refusals.get(sf).push({
                     crash: { message, className, loc: locOf7(stmt) },
                     fallback: unsupportedDiag("SC1010", locOf7(stmt), fallbackFeature),
-                    pos: stmt.getStart(sf),
+                    pos: ts.tokenStartOfNode(stmt),
                 });
             };
             // Project modules win before npm fallback: this is the source graph
@@ -3566,21 +4630,39 @@ function preflight7(load) {
             }
             if (dep && !isJson) {
                 deps.push({ dep, stmt });
-                depPositions.get(sf).push({ dep, pos: stmt.getStart(sf) });
+                depPositions.get(sf).push({ dep, pos: ts.tokenStartOfNode(stmt) });
             }
         }
         {
             const jsRequireFile = isJsSourceFileName(sf.fileName);
-            const stmts = sf.statements;
-            let firstRunnable = -1;
-            stmts.forEach((s, i) => {
-                if (firstRunnable < 0 && !purePrefixStmt7(program, s))
-                    firstRunnable = i;
-            });
+            const stmts = sf.statements.nodes;
+            // A binding that code running before the require can reach. Node
+            // initializes it AT the require: a const/let read earlier throws
+            // ReferenceError, which the lowering reproduces with an
+            // initialization check at every reference that can run early
+            // (require-initialization.ts). A var reads undefined there, which
+            // module aliases cannot represent; createRequire bindings have no
+            // checked form either.
+            const earlyRequireFence = (req, bindingKind, loc) => {
+                const early = req.decl !== null ? requireEarlyReference7(program, req.decl) : null;
+                if (early === null ||
+                    (bindingKind !== "createRequire" &&
+                        ((req.decl.parent?.flags ?? 0) & (ts.NodeFlags.Const | ts.NodeFlags.Let)) !== 0)) {
+                    return false;
+                }
+                diags.push(unsupportedDiag("SC1013", loc, bindingKind === "createRequire"
+                    ? `createRequire() binding '${early.text}' below code that can reach it (Node throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first)`
+                    : `var require() binding '${early.text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — declare it with const or let, or move the require above the code that can run first)`));
+                return true;
+            };
             for (let k = 0; k < stmts.length; k++) {
                 const stmt = stmts[k];
                 for (const req of requiresOf7(stmt)) {
-                    const loc = { file: sf.fileName, start: req.node.getStart(sf), end: req.node.getEnd() };
+                    const loc = {
+                        file: sf.fileName,
+                        start: ts.tokenStartOfNode(req.node),
+                        end: req.node.end,
+                    };
                     const bindingKind = requireCallBindingKind7(program, req.node);
                     // TypeScript source files join this scan only through the
                     // canonical createRequire bridge. Their ordinary require-shaped
@@ -3597,20 +4679,72 @@ function preflight7(load) {
                     if (load.externalTypes.has(req.spec)) {
                         continue;
                     }
+                    // A JSON document: the require answers its cached parsed object
+                    // (json-require.ts), an ordinary value the binding stores, so
+                    // every destructuring form lowers as usual. No module edge.
+                    const jsonDep = resolveImport7(program, sf, req.spec, "require");
+                    if (jsonDep !== null && jsonDep.fileName.endsWith(".json")) {
+                        if (bindingKind === "createRequire")
+                            continue;
+                        if (ts.isVariableStatement(stmt) && requiresOf7(stmt).length > 1) {
+                            const others = requiresOf7(stmt).some((r) => {
+                                const d = resolveImport7(program, sf, r.spec, "require");
+                                return d === null || !d.fileName.endsWith(".json");
+                            });
+                            if (others) {
+                                diags.push(unsupportedDiag("SC1012", loc, "require() of a JSON module declared together with other require() bindings"));
+                                continue;
+                            }
+                        }
+                        earlyRequireFence(req, bindingKind, loc);
+                        continue;
+                    }
                     if (req.decl && ts.isArrayBindingPattern(req.decl.name)) {
                         diags.push(unsupportedDiag("SC1012", loc, "array-destructuring require() bindings"));
                         continue;
                     }
                     if (req.decl && ts.isObjectBindingPattern(req.decl.name)) {
-                        const bad = req.decl.name.elements.find((e) => e.name === undefined ||
-                            !ts.isIdentifier(e.name) ||
-                            e.initializer !== undefined ||
-                            e.dotDotDotToken !== undefined);
-                        if (bad) {
-                            diags.push(unsupportedDiag("SC1012", loc, "require() destructuring with defaults, rest, or nested patterns"));
+                        // A nested pattern of a builtin binds members of the sub-module
+                        // its key names (`const { types: { isPromise } } =
+                        // require("util")` — util.types IS util/types).
+                        const builtin = canonicalBuiltinModule(req.spec);
+                        const plainElements = (pattern, module) => pattern.elements.nodes.every((e) => {
+                            if (e.initializer !== undefined || e.dotDotDotToken !== undefined)
+                                return false;
+                            if (e.name !== undefined && ts.isIdentifier(e.name))
+                                return true;
+                            // A nested pattern under a named export of a program module
+                            // destructures that export's VALUE at the require
+                            // (`const { codes: { ERR_X } } = require("./errors")`): the
+                            // inner bindings are ordinary destructured storage.
+                            if (module === null &&
+                                builtin === null &&
+                                bindingKind !== "createRequire" &&
+                                pattern === req.decl.name &&
+                                e.name !== undefined &&
+                                ts.isObjectBindingPattern(e.name) &&
+                                e.propertyName !== undefined &&
+                                ts.isIdentifier(e.propertyName))
+                                return true;
+                            if (module === null || e.name === undefined || !ts.isObjectBindingPattern(e.name))
+                                return false;
+                            const key = e.propertyName;
+                            if (key === undefined || !ts.isIdentifier(key))
+                                return false;
+                            const sub = canonicalBuiltinModule(`${module}/${key.text}`);
+                            return sub !== null && plainElements(e.name, sub);
+                        });
+                        if (!plainElements(req.decl.name, builtin)) {
+                            diags.push(unsupportedDiag("SC1012", loc, builtin !== null
+                                ? "require() destructuring with defaults, rest, or nested patterns other than builtin sub-modules"
+                                : "require() destructuring with defaults, rest, or nested patterns of program modules (JSON documents and builtin sub-modules destructure fully)"));
                             continue;
                         }
                     }
+                    // An npm package served as a builtin (graceful-fs as fs) is never
+                    // a program-module edge, even when --npm-static names it.
+                    if (npmBuiltinAliasOf(req.spec) !== null)
+                        continue;
                     const isRelative = isRelativeSpecifier(req.spec);
                     let dep = resolveImport7(program, sf, req.spec, "require");
                     if (dep === null && !isRelative) {
@@ -3649,27 +4783,8 @@ function preflight7(load) {
                             continue;
                         }
                     }
-                    if (dep && dep.fileName.endsWith(".json")) {
-                        if (bindingKind === "createRequire")
-                            continue;
-                        diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
-                        continue;
-                    }
-                    // Earlier declarators run too: `const x = read(), dep =
-                    // require('./dep')` must not lose the guard merely because both
-                    // initializers share one VariableStatement.
-                    const precedingDecls = req.decl && ts.isVariableStatement(stmt)
-                        ? stmt.declarationList.declarations.slice(0, stmt.declarationList.declarations.indexOf(req.decl))
-                        : [];
-                    const prefixCanRun = (firstRunnable >= 0 && firstRunnable < k) ||
-                        precedingDecls.some((decl) => !purePrefixDecl7(decl));
-                    const tdzName = prefixCanRun && req.decl
-                        ? bindingEarlyUse7(program, sf, k, req.decl, precedingDecls)
-                        : null;
-                    if (tdzName !== null) {
-                        diags.push(unsupportedDiag("SC1013", loc, `require() below code that can reach its binding '${tdzName}' (Node initializes the binding AT the require and throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first)`));
+                    if (earlyRequireFence(req, bindingKind, loc))
                         continue;
-                    }
                     if (dep)
                         deps.push({ dep });
                 }
@@ -3680,7 +4795,7 @@ function preflight7(load) {
                 .prefetchSymbolNodesExact(nestedBareRequires.flatMap((call) => ts.isIdentifier(call.expression) ? [call.expression] : []));
             for (const call of nestedBareRequires) {
                 const spec = requireSpecOf7(call);
-                const loc = { file: sf.fileName, start: call.getStart(sf), end: call.getEnd() };
+                const loc = { file: sf.fileName, start: ts.tokenStartOfNode(call), end: call.end };
                 const bindingKind = requireCallBindingKind7(program, call);
                 if (!jsRequireFile && bindingKind !== "createRequire")
                     continue;
@@ -3693,14 +4808,14 @@ function preflight7(load) {
                 if (load.externalTypes.has(spec)) {
                     continue;
                 }
+                if (npmBuiltinAliasOf(spec) !== null)
+                    continue;
                 const projectDep = resolveImport7(program, sf, spec, "require");
                 if (projectDep !== null) {
-                    if (projectDep.fileName.endsWith(".json")) {
-                        if (bindingKind === "createRequire")
-                            continue;
-                        diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
+                    // A bare require of a JSON document only parses it: nothing to
+                    // evaluate (json-require.ts creates the cached object).
+                    if (projectDep.fileName.endsWith(".json"))
                         continue;
-                    }
                     deps.push({ dep: projectDep });
                     continue;
                 }
@@ -3728,6 +4843,36 @@ function preflight7(load) {
                     continue;
                 }
             }
+            // Inline requires of program modules are module edges like the bare
+            // statements above (cjs-inline-require.ts lowers each to the module's
+            // %init at its position). Only the CommonJS global in a CommonJS file
+            // counts, and targets outside the compiled graph add nothing here:
+            // their use sites keep their existing lowering fences.
+            if (jsRequireFile && !isNodeEsmFile7(sf, program)) {
+                for (const call of inlineRequiresOf7(sf)) {
+                    if (requireCallBindingKind7(program, call) !== "ambient")
+                        continue;
+                    const spec = requireSpecOf7(call);
+                    if (load.externalTypes.has(spec) || canonicalBuiltinModule(spec) !== null)
+                        continue;
+                    const lazy = inDeferredPosition7(call);
+                    const edgeTo = (dep) => lazy ? { dep, lazy: true, call } : { dep, call };
+                    const projectDep = resolveImport7(program, sf, spec, "require");
+                    if (projectDep !== null) {
+                        if (!projectDep.fileName.endsWith(".json"))
+                            deps.push(edgeTo(projectDep));
+                        continue;
+                    }
+                    if (isRelativeSpecifier(spec) || spec.startsWith("#"))
+                        continue;
+                    const npmReq = resolveNpmImport7(sf.fileName, spec, "require");
+                    if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
+                        const nDep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
+                        if (nDep !== null)
+                            deps.push(edgeTo(nDep));
+                    }
+                }
+            }
         }
     }
     // Node's evaluation order: depth-first postorder from the entry, each
@@ -3753,8 +4898,12 @@ function preflight7(load) {
     //    reads are all let/const bindings with module storage — the
     //    lowering checks each one (cycleEarlyBindings) and throws Node's
     //    ReferenceError on a read before the declaration ran.
-    const cycleAdmissionReason = makeCycleAdmission(program, (sf) => edges.get(sf) ?? []);
+    const cycleAdmissionReason = makeCycleAdmission(program, (sf) => {
+        const all = edges.get(sf) ?? [];
+        return all.some((e) => e.call !== undefined) ? all.filter((e) => e.call === undefined) : all;
+    });
     const order = [];
+    const inlineRequireCycleCalls = new Set();
     const state = new Map();
     const stack = [];
     const visit = (sf) => {
@@ -3763,10 +4912,16 @@ function preflight7(load) {
         for (const e of edges.get(sf) ?? []) {
             if (e.dep === sf)
                 continue; // self-import: a Node cache hit, not a cycle
+            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) {
+                    inlineRequireCycleCalls.add(e.call);
+                    continue;
+                }
                 // A back-edge: Node answers it from the cache (the module is
                 // already evaluating) — admitted by the cheap per-edge rule, the
                 // declaration-only init window rule, or the exact initialization
@@ -3784,6 +4939,12 @@ function preflight7(load) {
         stack.pop();
         state.set(sf, "done");
         order.push(sf);
+        // Lazy inline requires run after this module's top level: their
+        // modules join the order afterwards (cache hits when already loaded).
+        for (const e of edges.get(sf) ?? []) {
+            if (e.lazy === true && state.get(e.dep) === undefined)
+                visit(e.dep);
+        }
     };
     visit(entry);
     // The startup crash Node's RESOLUTION phase reports: modules resolve
@@ -3833,7 +4994,12 @@ function preflight7(load) {
     const linkCrash = resolveCrash !== null
         ? null
         : earlierLinkCrash(order, cjsNamedImportLinkCheck(program, entry, order, diags), esmNamedImportLinkCheck(program, entry, order, diags));
-    return { diags, moduleOrder: order, startupCrash: resolveCrash ?? linkCrash };
+    return {
+        diags,
+        moduleOrder: order,
+        startupCrash: resolveCrash ?? linkCrash,
+        inlineRequireCycleCalls,
+    };
 }
 /** Walks the entry's ESM instantiate graph exactly as V8 does — children
  * in request order, each module's own imports checked AFTER its children
@@ -3867,12 +5033,19 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
             npmStaticDepSf7(program, from, spec, "require");
         return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
     };
+    // A bundler rewrite spells some lexer-visible names as accessors.
+    const lexWithAccessorNames = (sf) => {
+        const lexed = cjsLexedExportsOfFile(sf);
+        for (const name of npmStaticLexerVisibleNames(sf.fileName))
+            lexed.exports.add(name);
+        return lexed;
+    };
     const visible = (dep, name) => 
     // `default` is the module.exports binding itself — always provided.
     // The program already owns native source ASTs; reuse them without
     // starting another syntax session or reparsing their source text.
     name === "default" ||
-        cjsVisibleNames(dep, cjsLexedExportsOfFile, resolveCjsDep, lexMemo).has(name);
+        cjsVisibleNames(dep, lexWithAccessorNames, resolveCjsDep, lexMemo).has(name);
     /** The statement's resolved LOCAL CommonJS dependency, when it is an
      * import/re-export from one. */
     const cjsDepOf = (sf, spec) => {
@@ -3884,7 +5057,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
      * then `export { x } from` elements in source order. */
     const firstInvisibleOf = (sf) => {
         const entries = [];
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isImportDeclaration(stmt) ||
                 stmt.moduleSpecifier === undefined ||
                 !ts.isStringLiteral(stmt.moduleSpecifier))
@@ -3898,7 +5071,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
             const dep = cjsDepOf(sf, spec);
             if (dep === null)
                 continue;
-            for (const e of clause.namedBindings.elements) {
+            for (const e of clause.namedBindings.elements.nodes) {
                 if (e.isTypeOnly)
                     continue;
                 const nameNode = e.propertyName ?? e.name;
@@ -3910,7 +5083,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
             if (!visible(e.dep, e.exportName))
                 return { exportName: e.exportName, spec: e.spec, nameNode: e.nameNode, sf };
         }
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly)
                 continue;
             if (stmt.moduleSpecifier === undefined || !ts.isStringLiteral(stmt.moduleSpecifier))
@@ -3921,7 +5094,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
             const dep = cjsDepOf(sf, spec);
             if (dep === null)
                 continue;
-            for (const e of stmt.exportClause.elements) {
+            for (const e of stmt.exportClause.elements.nodes) {
                 if (e.isTypeOnly)
                     continue;
                 const nameNode = e.propertyName ?? e.name;
@@ -3940,7 +5113,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
         if (visited.has(sf))
             return null;
         visited.add(sf);
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
                 continue;
             if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt))
@@ -3981,7 +5154,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
     // it is CommonJS (module_job.js consults the ROOT job's moduleRequests/
     // commonJsDeps — a deep module's failure keeps the generic wording).
     let flavored = false;
-    for (const stmt of entry.statements) {
+    for (const stmt of entry.statements.nodes) {
         if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
             continue;
         if (ts.isImportDeclaration(stmt) &&
@@ -4008,7 +5181,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
     // swaps ` as ` for `: ` — reproduced exactly, quirks included
     // (multi-line import statements simply lose the hint).
     const text = bad.sf.text;
-    const pos = bad.nameNode.getStart(bad.sf);
+    const pos = ts.tokenStartOfNode(bad.nameNode);
     const lineStart = text.lastIndexOf("\n", pos - 1) + 1;
     const lineEnd = text.indexOf("\n", pos);
     let line = text.slice(lineStart, lineEnd < 0 ? text.length : lineEnd);
@@ -4066,9 +5239,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
             // type-only, but the native ESM linker sees the runtime placeholder.
             if (name === "default" &&
                 hasNodeTsDefaultInterfacePlaceholder7(dep) &&
-                checker
-                    .declarationsOf(resolved)
-                    .some((declaration) => ts.isInterfaceDeclaration(declaration) &&
+                resolved.declarations.some((declaration) => ts.isInterfaceDeclaration(declaration) &&
                     ts
                         .getModifiers(declaration)
                         ?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) === true &&
@@ -4087,7 +5258,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
         if (name === "default")
             return undefined;
         let starExport;
-        for (const stmt of dep.statements) {
+        for (const stmt of dep.statements.nodes) {
             if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly || stmt.exportClause !== undefined)
                 continue;
             if (stmt.moduleSpecifier === undefined || !ts.isStringLiteral(stmt.moduleSpecifier))
@@ -4106,7 +5277,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
     };
     const firstMissingOf = (sf) => {
         const imports = [];
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
                 continue;
             const clause = stmt.importClause;
@@ -4127,7 +5298,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
             }
             if (clause.namedBindings === undefined || !ts.isNamedImports(clause.namedBindings))
                 continue;
-            for (const element of clause.namedBindings.elements) {
+            for (const element of clause.namedBindings.elements.nodes) {
                 if (element.isTypeOnly)
                     continue;
                 const nameNode = element.propertyName ?? element.name;
@@ -4154,7 +5325,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
                 };
             }
         }
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly)
                 continue;
             const moduleSpecifier = stmt.moduleSpecifier;
@@ -4167,7 +5338,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
             const dep = resolveEdge(sf, spec);
             if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program))
                 continue;
-            for (const element of exportClause.elements) {
+            for (const element of exportClause.elements.nodes) {
                 if (element.isTypeOnly)
                     continue;
                 const nameNode = element.propertyName ?? element.name;
@@ -4186,7 +5357,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
         if (visited.has(sf))
             return null;
         visited.add(sf);
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
                 continue;
             if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt))
@@ -4268,17 +5439,17 @@ function earlierLinkCrash(moduleOrder, first, second) {
             return first.loc.start < second.loc.start ? first : second;
         const rank = (crash) => {
             const entries = [];
-            for (const stmt of sf.statements) {
+            for (const stmt of sf.statements.nodes) {
                 if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier)) {
                     const clause = stmt.importClause;
                     if (clause?.phaseModifier === ts.SyntaxKind.TypeKeyword)
                         continue;
                     if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-                        for (const element of clause.namedBindings.elements) {
+                        for (const element of clause.namedBindings.elements.nodes) {
                             if (!element.isTypeOnly) {
                                 entries.push({
                                     local: element.name.text,
-                                    start: (element.propertyName ?? element.name).getStart(sf),
+                                    start: ts.tokenStartOfNode(element.propertyName ?? element.name),
                                     kind: 0,
                                 });
                             }
@@ -4291,16 +5462,16 @@ function earlierLinkCrash(moduleOrder, first, second) {
             if (direct >= 0)
                 return [0, direct];
             let reexport = 0;
-            for (const stmt of sf.statements) {
+            for (const stmt of sf.statements.nodes) {
                 const exportClause = ts.isExportDeclaration(stmt) ? stmt.exportClause : undefined;
                 if (!ts.isExportDeclaration(stmt) ||
                     stmt.isTypeOnly ||
                     exportClause === undefined ||
                     !ts.isNamedExports(exportClause))
                     continue;
-                for (const element of exportClause.elements) {
+                for (const element of exportClause.elements.nodes) {
                     if (!element.isTypeOnly &&
-                        (element.propertyName ?? element.name).getStart(sf) === crash.loc.start) {
+                        ts.tokenStartOfNode(element.propertyName ?? element.name) === crash.loc.start) {
                         return [1, reexport];
                     }
                     if (!element.isTypeOnly)
@@ -4328,54 +5499,38 @@ const nodeBuiltinNames = new Set(builtinModules);
  * established (the phase-2 port kept every spelling); the world-neutral
  * helpers re-export from their focused modules. */
 export { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath } from "./dts-paths.js";
-export { builtinDefaultImportModule, canonicalBuiltinModule, SUPPORTED_BUILTIN_MODULES, } from "./builtin-modules.js";
+export { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_BUILTIN_MODULES, } from "./builtin-modules.js";
 export { npmPackageNameOf, workspacePackageOfPath } from "./workspace-registry.js";
-export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, };
+export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
 /** True for JavaScript source files (.js/.mjs/.cjs) — the files whose
  * types come entirely from inference (checkJs + JSDoc) and whose classes
  * declare fields by constructor assignment. */
 export function isJsSourceFile(sf) {
     return isJsSourceFileName(sf.fileName);
 }
-/** `import type …` declarations and named clauses whose every element is
- * `type`-qualified are ERASED by tsc at emit — Node's module graph has no
- * edge there, so module order, cycle detection, init calls, and the
- * startup-refusal probe must not count them either (zod v4's core modules
- * are "cyclic" only through `import type * as ns` namespaces — 27 phantom
- * SC1016 sites against 1 real value-level cycle; and a type-only import
- * of a module Node cannot resolve is NOT a startup crash — Node never
- * resolves it). Originated as the provenance-sources pilot's flag-gated
- * prototype (SCRIPTC_TYPE_ONLY_EDGES), promoted to always-on with the
- * full-suite differential green. Side-effect imports (no clause) stay
- * real edges. */
-function erasedTypeOnlyImport(stmt) {
-    const clause = stmt.importClause;
-    if (clause === undefined)
-        return false; // side-effect import: a real edge
-    if (clause.phaseModifier === ts.SyntaxKind.TypeKeyword)
-        return true;
-    return (clause.name === undefined &&
-        clause.namedBindings !== undefined &&
-        ts.isNamedImports(clause.namedBindings) &&
-        clause.namedBindings.elements.length > 0 &&
-        clause.namedBindings.elements.every((e) => e.isTypeOnly));
-}
-/** The re-export twin: `export { type X } from "./m"` with every element
- * `type`-qualified erases at emit exactly like `export type { X } from`
- * (which stmt.isTypeOnly already covers) — no module edge. */
-function erasedTypeOnlyReexport(stmt) {
-    return (stmt.exportClause !== undefined &&
-        ts.isNamedExports(stmt.exportClause) &&
-        stmt.exportClause.elements.length > 0 &&
-        stmt.exportClause.elements.every((e) => e.isTypeOnly));
+/** True for a JavaScript file of the program that TypeScript type-checks:
+ * one with a `// @ts-check` comment before its first statement, or any
+ * file of a project whose tsconfig sets `checkJs` unless the file has a
+ * `// @ts-nocheck` comment. Files under node_modules are never checked. */
+export function isCheckedJsSourceFile(sf, projectCheckJs) {
+    if (!isJsSourceFile(sf) || isNodeModulesPath(sf.fileName))
+        return false;
+    let checked = projectCheckJs;
+    const head = sf.text.slice(0, (sf.statements.nodes.length === 0 ? undefined : ts.tokenStartOfNode(sf.statements.nodes[0])) ??
+        sf.text.length);
+    for (const line of head.split("\n")) {
+        const directive = /^\s*\/\/\s*@ts-(no)?check\b/.exec(line);
+        if (directive)
+            checked = directive[1] === undefined;
+    }
+    return checked;
 }
 export function orderedImportsOf(program, sf) {
     const out = [];
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt))
             continue;
-        if (ts.isExportDeclaration(stmt) &&
-            (stmt.isTypeOnly || erasedTypeOnlyReexport(stmt) || !stmt.moduleSpecifier))
+        if (ts.isExportDeclaration(stmt) && (stmt.isTypeOnly || !stmt.moduleSpecifier))
             continue;
         if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt))
             continue;
@@ -4394,6 +5549,58 @@ export function orderedImportsOf(program, sf) {
     }
     return out;
 }
+/** The files a compiled program can load: the module order closed over
+ * every literal require() and import() call it contains (deferred and
+ * nested ones included) and, for opted-in package JavaScript, over every
+ * import and export declaration as well. A package file outside this set
+ * is reachable only through types, so whatever it spells cannot affect
+ * the compiled program. Null when a reachable file loads a computed
+ * specifier: then any file may load. */
+export function npmStaticLoadableFiles(program, moduleOrder) {
+    const seen = new Set();
+    const work = [];
+    const add = (sf) => {
+        if (sf === null || sf === undefined || seen.has(sf) || sf.isDeclarationFile)
+            return;
+        seen.add(sf);
+        work.push(sf);
+    };
+    for (const sf of moduleOrder)
+        add(sf);
+    let computed = false;
+    while (work.length > 0 && !computed) {
+        const sf = work.pop();
+        const packageJs = npmStaticPackageOfPath(sf.fileName) !== null && isJsSourceFileName(sf.fileName);
+        const follow = (spec, kind) => {
+            if (canonicalBuiltinModule(spec) !== null)
+                return;
+            add(resolveImport7(program, sf, spec, kind) ?? npmStaticDepSf7(program, sf, spec, kind));
+        };
+        ts.walkPreorder(sf, (n) => {
+            if (computed)
+                return "stop";
+            if (ts.isCallExpression(n)) {
+                const isImport = n.expression.kind === ts.SyntaxKind.ImportKeyword;
+                const isRequire = ts.isIdentifier(n.expression) && n.expression.text === "require";
+                if (!isImport && !isRequire)
+                    return undefined;
+                const arg = n.arguments.nodes[0];
+                if (arg !== undefined && ts.isStringLiteralLike(arg))
+                    follow(arg.text, isImport ? "import" : "require");
+                else if (packageJs || isImport)
+                    computed = true;
+            }
+            else if (packageJs &&
+                (ts.isImportDeclaration(n) || ts.isExportDeclaration(n)) &&
+                n.moduleSpecifier !== undefined &&
+                ts.isStringLiteral(n.moduleSpecifier)) {
+                follow(n.moduleSpecifier.text, "import");
+            }
+            return undefined;
+        });
+    }
+    return computed ? null : new Set([...seen].map((sf) => sf.fileName.split("\\").join("/")));
+}
 /** The program source file a bare specifier reaches when it names an
  * opted-in --npm-static package (the shipped-JS entry preflight admitted
  * as a module edge), else null. No offender reporting here — preflight
@@ -4435,6 +5642,19 @@ export function cjsExportAssignmentOf(stmt) {
     if (isModuleExportsAccess(e.left)) {
         return { kind: "table", obj: ts.isObjectLiteralExpression(e.right) ? e.right : null, expr: e };
     }
+    if (ts.isIdentifier(e.left) && e.left.text === "exports") {
+        let inner = e.right;
+        while (ts.isParenthesizedExpression(inner))
+            inner = inner.expression;
+        if (ts.isBinaryExpression(inner) &&
+            inner.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            isModuleExportsAccess(inner.left) &&
+            // `exports = module.exports = {}` is the fresh-table reset, which the
+            // export walk handles on its own.
+            !ts.isObjectLiteralExpression(inner.right)) {
+            return { kind: "table", obj: null, expr: inner, rebindsExports: true };
+        }
+    }
     if (ts.isPropertyAccessExpression(e.left) && !e.left.questionDotToken) {
         const recv = e.left.expression;
         const isExports = ts.isIdentifier(recv) && recv.text === "exports";
@@ -4444,6 +5664,85 @@ export function cjsExportAssignmentOf(stmt) {
     }
     return null;
 }
+/** The tsc VOID-INIT PREAMBLE (`exports.a = exports.b = void 0;` with the
+ * real `exports.a = a;` further down; every tsc-emitted dist file opens its
+ * exports this way): when every name in the chain has a later real
+ * assignment, the export takes its value there and the preamble lowers to
+ * nothing. Returns those later assignments by name, or null when this is
+ * not such a preamble (a preamble with no later real assignment keeps the
+ * ordinary path: the export IS undefined then). */
+export function cjsVoidInitPreambleReals(cjs) {
+    if (!ts.isIdentifier(cjs.name))
+        return null;
+    const isExportsMember = (e) => ts.isPropertyAccessExpression(e) &&
+        ts.isIdentifier(e.name) &&
+        ((ts.isIdentifier(e.expression) && e.expression.text === "exports") ||
+            (ts.isPropertyAccessExpression(e.expression) &&
+                ts.isIdentifier(e.expression.expression) &&
+                e.expression.expression.text === "module" &&
+                ts.isIdentifier(e.expression.name) &&
+                e.expression.name.text === "exports"));
+    const isVoid = (e) => {
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        return (e.kind === ts.SyntaxKind.VoidExpression || (ts.isIdentifier(e) && e.text === "undefined"));
+    };
+    // chains: `exports.a = exports.b = void 0;` collects every name
+    const names = [cjs.name.text];
+    let tail = cjs.value;
+    while (ts.isBinaryExpression(tail) &&
+        tail.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        isExportsMember(tail.left)) {
+        names.push(tail.left.name.text);
+        tail = tail.right;
+    }
+    if (!isVoid(tail))
+        return null;
+    const sf = ts.getSourceFileOfNode(cjs.expr);
+    const myPos = ts.tokenStartOfNode(cjs.expr);
+    const reals = new Map();
+    for (const name of names) {
+        const real = sf.statements.nodes
+            .map((s) => cjsExportAssignmentOf(s))
+            .find((other) => other?.kind === "member" &&
+            ts.isIdentifier(other.name) &&
+            other.name.text === name &&
+            ts.tokenStartOfNode(other.expr) > myPos &&
+            !isVoid(other.value));
+        if (real?.kind !== "member")
+            return null;
+        reals.set(name, real);
+    }
+    return reals;
+}
+/** The members and shared value of a CHAINED member export
+ * `exports.a = exports.b = module.exports.c = value` (outermost name
+ * first), or null when the assignment is not a chain of at least two
+ * identifier-named export members or its value is undefined. */
+export function cjsExportChainOf(e) {
+    const names = [];
+    let cur = e;
+    for (;;) {
+        while (ts.isParenthesizedExpression(cur))
+            cur = cur.expression;
+        if (!ts.isBinaryExpression(cur) || cur.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+            break;
+        const left = cur.left;
+        if (!ts.isPropertyAccessExpression(left) ||
+            left.questionDotToken ||
+            !ts.isIdentifier(left.name))
+            break;
+        const recv = left.expression;
+        if (!((ts.isIdentifier(recv) && recv.text === "exports") || isModuleExportsAccess(recv)))
+            break;
+        names.push(left.name);
+        cur = cur.right;
+    }
+    // tsc's `exports.a = exports.b = void 0;` preamble is not a value chain
+    // (the export-statement lowering owns it).
+    const isVoid = cur.kind === ts.SyntaxKind.VoidExpression || (ts.isIdentifier(cur) && cur.text === "undefined");
+    return names.length >= 2 && !isVoid ? { names, value: cur } : null;
+}
 /** Why Node would DISCARD this CommonJS export statement, or null when it
  * survives (Node's export-object identity rules — checker-free, pure
  * AST): `module.exports = {...}` REPLACES the export object, so members
@@ -4459,7 +5758,7 @@ export function cjsExportDiscardReason(stmt) {
     const mine = cjsExportAssignmentOf(stmt);
     if (!mine)
         return null;
-    const stmts = sf.statements;
+    const stmts = sf.statements.nodes;
     let lastTable = -1;
     for (let i = 0; i < stmts.length; i++) {
         if (cjsExportAssignmentOf(stmts[i])?.kind === "table")
@@ -4477,6 +5776,9 @@ export function cjsExportDiscardReason(stmt) {
         return "export members attached before a 'module.exports =' assignment (Node replaces the export object — importers never see this member; attach it to module.exports AFTER the table)";
     }
     const left = mine.expr.left;
+    const last = cjsExportAssignmentOf(stmts[lastTable]);
+    if (last?.kind === "table" && last.rebindsExports === true)
+        return null;
     return ts.isIdentifier(left.expression) && left.expression.text === "exports"
         ? "'exports.f =' after a 'module.exports =' assignment ('exports' still references the replaced object — Node discards this member; write module.exports.f instead)"
         : null;
@@ -4496,16 +5798,16 @@ export function cjsExportTargetLiteral(e, sf) {
     if (ts.isNewExpression(e) &&
         ts.isIdentifier(e.expression) &&
         e.expression.text === "Proxy" &&
-        (e.arguments?.length ?? 0) >= 1) {
-        return cjsExportTargetLiteral(e.arguments[0], sf);
+        (e.arguments?.nodes.length ?? 0) >= 1) {
+        return cjsExportTargetLiteral(e.arguments.nodes[0], sf);
     }
     if (ts.isIdentifier(e)) {
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             if (!ts.isVariableStatement(stmt))
                 continue;
             if ((stmt.declarationList.flags & ts.NodeFlags.Const) === 0)
                 continue;
-            for (const d of stmt.declarationList.declarations) {
+            for (const d of stmt.declarationList.declarations.nodes) {
                 if (d.name !== undefined &&
                     ts.isIdentifier(d.name) &&
                     d.name.text === e.text &&
@@ -4527,7 +5829,7 @@ export function cjsExportTargetLiteral(e, sf) {
  * order against it). Null when the kept export is anything else. */
 export function cjsClassExprWholeExportOf(sf) {
     let last = null;
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         const cjs = cjsExportAssignmentOf(stmt);
         if (!cjs || cjs.kind !== "table")
             continue;
@@ -4558,10 +5860,10 @@ export function isCjsExportTableLiteral(obj) {
     const decl = obj.parent;
     if (!ts.isVariableDeclaration(decl) || decl.initializer !== obj)
         return false;
-    const sf = obj.getSourceFile();
+    const sf = ts.getSourceFileOfNode(obj);
     if (!isJsSourceFile(sf))
         return false;
-    for (const stmt of sf.statements) {
+    for (const stmt of sf.statements.nodes) {
         const cjs = cjsExportAssignmentOf(stmt);
         if (cjs?.kind === "table" && cjsExportDiscardReason(stmt) === null) {
             return cjsExportTargetLiteral(cjs.expr.right, sf) === obj;
@@ -4668,7 +5970,7 @@ function receiverRoot(text, pos) {
 /** Whether `name` is bound in `fileName` by an import of a Node builtin. */
 function importsNodeBuiltin(load, fileName, name) {
     const sf = load.program.getSourceFile(fileName);
-    for (const stmt of sf?.statements ?? []) {
+    for (const stmt of sf?.statements?.nodes ?? []) {
         if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
             continue;
         if (canonicalBuiltinModule(stmt.moduleSpecifier.text) === null)
@@ -4681,7 +5983,7 @@ function importsNodeBuiltin(load, fileName, name) {
             return true;
         if (bindings &&
             ts.isNamedImports(bindings) &&
-            bindings.elements.some((e) => e.name.text === name))
+            bindings.elements.nodes.some((e) => e.name.text === name))
             return true;
     }
     return false;