@scriptc/compiler 0.1.7 → 0.2.1

package/dist/frontend/program.js

@@ -46,15 +46,17 @@ import { isNodeModulesPath, nearestInvalidPackageJsonPath, nearestPackageType, n
 import { probeNodeImportRefusal, probeNodeRequireRefusal } from "./npm.js";
 import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticDeclarationOverloads, setNpmStaticPackages } from "./npm-static.js";
 import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.js";
-import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties } from "./npm-static-declarations.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 { cjsLexerVisibleNames } from "./cjs-lexer.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 { 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 { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
 const BASE_OPTIONS = {
     strict: true,
 };
@@ -242,7 +244,7 @@ function runtimeReexportTarget(fromFile, specifier) {
 /** Visits an opted package's own declaration entry and relative barrel
  * closure. This is intentionally narrower than TypeScript module
  * resolution: bare edges name other packages and never inherit trust. */
-function visitNpmStaticDeclarationClosure(entryPath, onSource) {
+function visitNpmStaticDeclarationClosure(services, entryPath, onSource) {
     const seen = new Set();
     const packageJson = nearestPkgJsonPath(entryPath);
     const packageRoot = (packageJson === null ? dirname(entryPath) : dirname(packageJson)).split("\\").join("/");
@@ -258,7 +260,7 @@ function visitNpmStaticDeclarationClosure(entryPath, onSource) {
         if (source === null)
             return;
         onSource(path, source);
-        for (const specifier of npmStaticDeclarationReexports(path, source)) {
+        for (const specifier of npmStaticDeclarationReexports(services.parse(path, source, "ts"))) {
             const target = declarationReexportTarget(path, specifier);
             if (target !== null)
                 visit(target);
@@ -266,10 +268,10 @@ function visitNpmStaticDeclarationClosure(entryPath, onSource) {
     };
     visit(entryPath);
 }
-function npmStaticDeclarationOverloadsOf(entryPath) {
+function npmStaticDeclarationOverloadsOf(services, entryPath) {
     const classes = new Map();
-    visitNpmStaticDeclarationClosure(entryPath, (path, source) => {
-        for (const [className, methods] of parseNpmStaticDeclarationOverloads(path, source)) {
+    visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
+        for (const [className, methods] of parseNpmStaticDeclarationOverloads(services.parse(path, source, "ts"))) {
             const target = classes.get(className) ?? new Map();
             classes.set(className, target);
             for (const [methodName, signatures] of methods) {
@@ -280,10 +282,10 @@ function npmStaticDeclarationOverloadsOf(entryPath) {
     });
     return classes;
 }
-function npmStaticDeclarationPropertiesOf(entryPath) {
+function npmStaticDeclarationPropertiesOf(services, entryPath) {
     const classes = new Map();
-    visitNpmStaticDeclarationClosure(entryPath, (path, source) => {
-        for (const [className, properties] of parseNpmStaticDeclarationProperties(path, source)) {
+    visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
+        for (const [className, properties] of parseNpmStaticDeclarationProperties(services.parse(path, source, "ts"))) {
             const target = classes.get(className) ?? new Map();
             classes.set(className, target);
             for (const [propertyName, type] of properties) {
@@ -380,18 +382,27 @@ function createRequireProgramRoots7(program) {
     for (const sf of program.getSourceFiles()) {
         if (sf.isDeclarationFile || sf.fileName.endsWith(".json"))
             continue;
+        const calls = [];
         ts.walkPreorder(sf, (node) => {
             if (!ts.isCallExpression(node) || node.questionDotToken !== undefined ||
                 node.arguments.length !== 1 || !ts.isStringLiteralLike(node.arguments[0]) ||
-                !ts.isIdentifier(node.expression) || !isCreateRequireBinding7(program, node.expression)) {
+                !ts.isIdentifier(node.expression)) {
                 return undefined;
             }
-            const spec = node.arguments[0].text;
+            calls.push({ callee: node.expression, spec: node.arguments[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,
+        // including all unreachable bodies in large published packages.
+        program.getTypeChecker().prefetchSymbolNodesExact(calls.map((call) => call.callee));
+        for (const { callee, spec } of calls) {
+            if (!isCreateRequireBinding7(program, callee))
+                continue;
             if (canonicalBuiltinModule(spec) !== null)
-                return "skip";
+                continue;
             let target = resolveProjectModule(sf.fileName, spec);
             if (target === null && !spec.startsWith("#")) {
-                const npm = resolveNpmImport7(sf.fileName, spec);
+                const npm = resolveNpmImport7(sf.fileName, spec, "require");
                 if (npm !== null && isNpmStaticPackage(npm.packageName) && isJsSourceFileName(npm.typesFile)) {
                     target = npm.typesFile;
                 }
@@ -400,12 +411,11 @@ function createRequireProgramRoots7(program) {
             // out of TypeScript's source roots so the require call can report
             // the native-addon boundary instead of an unsupported-file error.
             if (target === null || target.endsWith(".json") || target.endsWith(".node"))
-                return "skip";
+                continue;
             const normalized = tsgoPath(resolve(target));
             if (!known.has(normalized))
                 roots.add(normalized);
-            return "skip";
-        });
+        }
     }
     return [...roots].sort();
 }
@@ -422,22 +432,20 @@ export function entryPackageFilePredicate(entryPath) {
             !normalized.slice(prefix.length).split("/").includes("node_modules"));
     };
 }
-/** maxNodeModuleJsDepth omits even relative JS imports within an installed
- * entry's own package. Add those sources as roots to the existing discovery
- * fixpoint without raising the checker depth for other packages. */
+/** 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) {
-    if (!isNodeModulesPath(entryPath))
-        return [];
     const belongsToEntry = entryPackageFilePredicate(entryPath);
     const roots = new Set();
     for (const sf of program.getSourceFiles()) {
-        if (sf.isDeclarationFile || !belongsToEntry(sf.fileName))
+        if (sf.isDeclarationFile || (!belongsToEntry(sf.fileName) && npmStaticPackageOfPath(sf.fileName) === null))
             continue;
         for (const specifier of sf.imports) {
             if (!ts.isStringLiteralLike(specifier))
                 continue;
             const target = resolveProjectModule(sf.fileName, specifier.text);
-            if (target !== null && belongsToEntry(target) && isJsSourceFileName(target) &&
+            if (target !== null && (belongsToEntry(target) || npmStaticPackageOfPath(target) !== null) && isJsSourceFileName(target) &&
                 program.getSourceFile(target) === undefined)
                 roots.add(target);
         }
@@ -482,52 +490,54 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
     }
     const coreRoots = [entryPath, ambientDtsPath(), nodeTypes ?? fallbackDtsPath()];
     const programRoots = [...coreRoots];
-    let program = ts.createProgram([...programRoots, overridesDtsPath()], options, host);
-    for (let pass = 0; pass < 32; pass++) {
-        const candidates = [
-            ...entryPackageProgramRoots7(program, entryPath),
-            ...createRequireProgramRoots7(program),
-            ...forkTargetPaths(program, program.getSourceFiles()),
-        ];
-        const extraRoots = candidates.filter((root, index) => !programRoots.includes(root) && candidates.indexOf(root) === index);
-        if (extraRoots.length === 0)
-            break;
-        program.dispose();
-        programRoots.push(...extraRoots);
-        program = ts.createProgram([...programRoots, overridesDtsPath()], options, host);
-        if (pass === 31)
-            throw new Error("static program-root discovery did not converge");
-    }
-    const entry = program.getSourceFile(entryPath);
-    if (!entry)
-        throw new Error(`could not load ${entryPath}`);
-    const externalTypeSpecifiersByFile = externalTypeFileClosure7(program, externalTypes);
-    let projectWorld = null;
-    return {
-        program,
-        entry,
-        moduleOrder: [],
-        configDiags: config.diags,
-        externalTypes,
-        externalTypeSpecifiersByFile,
-        projectWorld: () => (projectWorld ??= ts.createProgram(programRoots, options, host)),
-        disposeAll: () => {
-            projectWorld?.dispose();
+    let program = host.createProgram([...programRoots, overridesDtsPath()], options);
+    try {
+        for (let pass = 0; pass < 32; pass++) {
+            const candidates = [
+                ...entryPackageProgramRoots7(program, entryPath),
+                ...createRequireProgramRoots7(program),
+                ...forkTargetPaths(program, program.getSourceFiles()),
+            ];
+            const extraRoots = candidates.filter((root, index) => !programRoots.includes(root) && candidates.indexOf(root) === index);
+            if (extraRoots.length === 0)
+                break;
             program.dispose();
-        },
-    };
+            programRoots.push(...extraRoots);
+            program = host.createProgram([...programRoots, overridesDtsPath()], options);
+            if (pass === 31)
+                throw new Error("static program-root discovery did not converge");
+        }
+        const entry = program.getSourceFile(entryPath);
+        if (!entry)
+            throw new Error(`could not load ${entryPath}`);
+        const externalTypeSpecifiersByFile = externalTypeFileClosure7(program, externalTypes);
+        let projectWorld = null;
+        return {
+            program,
+            entry,
+            moduleOrder: [],
+            configDiags: config.diags,
+            externalTypes,
+            externalTypeSpecifiersByFile,
+            projectWorld: () => (projectWorld ??= host.createProgram(programRoots, options)),
+            disposeAll: () => {
+                try {
+                    projectWorld?.dispose();
+                }
+                finally {
+                    program.dispose();
+                }
+            },
+        };
+    }
+    catch (error) {
+        program.dispose();
+        throw error;
+    }
 }
-/** The pipeline surface: ONE tsgo program serves preflight AND the
- * lowering. The caller runs checkPreflight, hands program/entry/
- * moduleOrder straight to lowerToIr, and MUST dispose() when done — the
- * spawned tsgo server must not outlive the compile. */
-export function loadProgram(entryPath, opts) {
-    // Absolute from the start: tsgo's world is absolute-path-keyed (the CLI
-    // resolves before calling; this covers direct API callers too).
+export function loadProgram(entryPath, services, opts) {
     entryPath = resolve(entryPath);
-    const externalTypeEntries = opts?.externalTypes instanceof Map
-        ? [...opts.externalTypes]
-        : Object.entries(opts?.externalTypes ?? {});
+    const externalTypeEntries = opts?.externalTypes ?? [];
     const externalTypes = new Map();
     for (const [specifier, file] of externalTypeEntries) {
         if (!isExactExternalTypeSpecifier(specifier)) {
@@ -549,6 +559,7 @@ export function loadProgram(entryPath, opts) {
     // or executable module edges.
     const declarationOverloads = new Map();
     const declarationProperties = new Map();
+    const projectionOwners = new Map();
     for (const pkg of npmStaticPackages) {
         const resolved = resolveBareModule(entryPath, pkg, "types-only");
         if (resolved === null ||
@@ -556,8 +567,8 @@ export function loadProgram(entryPath, opts) {
             !/\.d\.(?:ts|mts|cts)$/.test(resolved.typesFile)) {
             continue;
         }
-        const overloads = npmStaticDeclarationOverloadsOf(resolved.typesFile);
-        const properties = npmStaticDeclarationPropertiesOf(resolved.typesFile);
+        const overloads = npmStaticDeclarationOverloadsOf(services, resolved.typesFile);
+        const properties = npmStaticDeclarationPropertiesOf(services, resolved.typesFile);
         const classNames = new Set([...overloads.keys(), ...properties.keys()]);
         if (classNames.size === 0)
             continue;
@@ -567,8 +578,8 @@ export function loadProgram(entryPath, opts) {
         const runtimeSource = trackedReadFile(runtime.typesFile);
         if (runtimeSource === null)
             continue;
-        const targets = npmStaticRuntimeClassTargets(runtime.typesFile, runtimeSource, classNames);
-        for (const [className, specifier] of targets) {
+        const targets = npmStaticRuntimeClassTargets(services.parse(runtime.typesFile, runtimeSource, "js"), runtimeSource, classNames);
+        for (const [className, { specifier, localName }] of targets) {
             const methods = overloads.get(className);
             const fields = properties.get(className);
             if (methods === undefined && fields === undefined)
@@ -582,14 +593,39 @@ export function loadProgram(entryPath, opts) {
                 targetNorm.startsWith(runtime.workspaceDir.split("\\").join("/") + "/");
             if (targetPackage !== pkg && !insideWorkspace)
                 continue;
+            const projectionKey = JSON.stringify([targetNorm, localName]);
+            const previousOwner = projectionOwners.get(projectionKey);
+            if (previousOwner !== undefined && previousOwner !== className) {
+                // Two public class declarations naming one runtime class are
+                // ambiguous. Keep inference instead of choosing one alias's ABI.
+                projectionOwners.set(projectionKey, null);
+                const priorMethods = new Map(declarationOverloads.get(targetNorm) ?? []);
+                priorMethods.delete(localName);
+                declarationOverloads.set(targetNorm, priorMethods);
+                const priorFields = new Map(declarationProperties.get(targetNorm) ?? []);
+                priorFields.delete(localName);
+                declarationProperties.set(targetNorm, priorFields);
+                continue;
+            }
+            projectionOwners.set(projectionKey, className);
+            // The safe declaration grammar can name only its own class. Bind
+            // that type to the actual runtime class after a named ESM alias.
+            const renameSelf = (type) => type.split(/([\s[\]<>()|,]+)/).map((name) => name === className ? localName : name).join("");
             if (methods !== undefined) {
                 const byClass = new Map(declarationOverloads.get(targetNorm) ?? []);
-                byClass.set(className, methods);
+                byClass.set(localName, new Map([...methods].map(([name, signatures]) => [name, signatures.map((signature) => ({
+                        parameters: signature.parameters.map((parameter) => ({
+                            name: parameter.name,
+                            type: renameSelf(parameter.type),
+                            optional: parameter.optional,
+                        })),
+                        returnType: renameSelf(signature.returnType),
+                    }))])));
                 declarationOverloads.set(targetNorm, byClass);
             }
             if (fields !== undefined) {
                 const byClass = new Map(declarationProperties.get(targetNorm) ?? []);
-                byClass.set(className, fields);
+                byClass.set(localName, new Map([...fields].map(([name, type]) => [name, renameSelf(type)])));
                 declarationProperties.set(targetNorm, byClass);
             }
         }
@@ -619,25 +655,55 @@ export function loadProgram(entryPath, opts) {
     // outside node_modules — the classic typed-JS-library entry — must not exist for
     // the checker, so its resolution lands on the JS Node actually loads;
     // resolve.ts answers the same sibling for scriptc's own edges).
-    const npmShadow = npmStaticFsShadow();
+    const npmShadow = npmStaticFsShadow(services);
     const fsShadow = {
         readFile: (path) => npmShadow?.readFile(path),
         hideFile: (path) => (npmShadow?.hideFile(path) ?? false) || projectDtsRuntimeSibling(path) !== null,
     };
-    const host = new ts.Ts7Host({ cwd: dirname(entryPath), fsShadow });
-    const load = loadProgram7(host, entryPath, externalTypes);
-    return {
-        ...load,
-        dispose: () => {
-            load.disposeAll();
-            host.close();
-        },
-    };
+    const host = services.createProgramHost({ cwd: dirname(entryPath), fsShadow });
+    try {
+        const load = loadProgram7(host, entryPath, externalTypes);
+        let authoredHost = null;
+        let authoredLoad = null;
+        return {
+            ...load,
+            services,
+            projectWorld: npmStaticPackages.length === 0 ? load.projectWorld : () => {
+                // Check authored code against the package's published declarations.
+                // Runtime bodies still lower from JavaScript in the original world;
+                // inference there must not manufacture errors in valid user code.
+                if (!authoredLoad) {
+                    authoredHost = services.createProgramHost({ cwd: dirname(entryPath) });
+                    authoredLoad = loadProgram7(authoredHost, entryPath, externalTypes);
+                }
+                return authoredLoad.projectWorld();
+            },
+            dispose: () => {
+                try {
+                    authoredLoad?.disposeAll();
+                }
+                finally {
+                    authoredHost?.close();
+                    try {
+                        load.disposeAll();
+                    }
+                    finally {
+                        host.close();
+                    }
+                }
+            },
+        };
+    }
+    catch (error) {
+        host.close();
+        throw error;
+    }
 }
 /** tsc diagnostics (syntax + types), the supported-import fence, and the
  * module evaluation order: fills load.moduleOrder (the SourceFiles
  * themselves — the lowering consumes them directly) and returns the
- * preflight diagnostics. The lowerer runs only on programs that pass. */
+ * 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);
     load.moduleOrder = moduleOrder;
@@ -657,7 +723,10 @@ export function checkPreflight(load) {
  *    assignments in CJS classes (`this[kSym] = v` under `module.exports =
  *    Class`) — 5.9.3 synthesized expando symbols, tsgo trips its
  *    redeclaration check instead (the corpus's countdown fixture). */
-const TS7_JS_RELAXED_EXTRA = new Set([2309, 2323]);
+// Ordinary JavaScript functions are constructable even when the checker
+// 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]);
 function suppressedJsStrictness7(d) {
     const file = d.fileName;
     if (!file || !isJsSourceFileName(file))
@@ -837,7 +906,7 @@ function purePrefixStmt7(program, s) {
         return true; // directive
     if (isRequireStatement7(s))
         return true;
-    if (isCjsJsFile7(s.getSourceFile())) {
+    if (isCjsJsFile7(s.getSourceFile(), program)) {
         if (ts.isExpressionStatement(s) && isEsModuleStamp(s.expression)) {
             const call = s.expression;
             const object = call.expression.expression;
@@ -855,11 +924,10 @@ function purePrefixStmt7(program, s) {
     }
     return false;
 }
-/** Can code that runs BEFORE the require statement at index `k` reach one
- * of the require's bindings? Node initializes them AT the require (TDZ —
- * earlier access is a ReferenceError), but the lowering aliases reads
- * through to the exporter's storage with no TDZ state, so a reachable
- * early read would silently diverge. Conservative reachability: earlier
+/** Can code that runs BEFORE the declaration at index `k` reach one of
+ * its bindings? Static require aliases and symbol field keys bypass
+ * storage reads, so an early use could erase a TDZ error or a var's
+ * initial undefined value. Conservative reachability: earlier
  * statements' whole subtrees (arrows and function expressions included)
  * read the binding directly, or reference a hoisted function/class whose
  * body (transitively through other hoisted declarations) reads it — a
@@ -870,7 +938,7 @@ function purePrefixStmt7(program, s) {
  * (The CheckerFacade memoizes symbol queries, and 7's client dedupes
  * symbol identity by server handle, so the Map-keyed-by-Symbol discipline
  * carries over from the 5.9.3 original unchanged.) */
-function requireTdzRisk7(program, sf, k, decl, precedingDecls) {
+export function bindingEarlyUse7(program, sf, k, decl, precedingDecls) {
     const checker = program.getTypeChecker();
     const bound = [];
     if (ts.isIdentifier(decl.name))
@@ -906,7 +974,9 @@ function requireTdzRisk7(program, sf, k, decl, precedingDecls) {
         // this scan must survive it so the nesting fence can answer later.
         ts.walkPreorder(root, (n) => {
             if (ts.isIdentifier(n)) {
-                const sym = checker.getSymbolAtLocation(n);
+                const sym = ts.isShorthandPropertyAssignment(n.parent)
+                    ? checker.getShorthandAssignmentValueSymbol(n.parent)
+                    : checker.getSymbolAtLocation(n);
                 if (sym) {
                     const name = bindings.get(sym);
                     if (name !== undefined) {
@@ -982,7 +1052,7 @@ function isCreateRequireImport7(program, ident) {
     const decl = symbol ? checker.declarationsOf(symbol)[0] : undefined;
     if (decl === undefined || !ts.isImportSpecifier(decl))
         return false;
-    const importDecl = decl.parent.parent.parent;
+    const importDecl = decl.parent?.parent?.parent;
     if (ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
         const module = canonicalBuiltinModule(importDecl.moduleSpecifier.text);
         const member = decl.propertyName?.text ?? decl.name.text;
@@ -1002,11 +1072,10 @@ function isCreateRequireImport7(program, ident) {
     }
     return false;
 }
-/** True only for the createRequire binding shape the lowering recognizes:
- * a const initialized from node:module's createRequire with a base naming
- * the current file. Arbitrary source declarations named `require` must not
- * ride the module-edge lowering, which would erase their calls. */
-function isCreateRequireBinding7(program, callee) {
+/** True only for createRequire bindings the lowering can erase. Mutable
+ * declaration syntax needs a whole-file proof: no writes or escapes, and
+ * no code before initialization can reach the binding. */
+export function isCreateRequireBinding7(program, callee) {
     const checker = program.getTypeChecker();
     const symbol = checker.getSymbolAtLocation(callee);
     const decl = symbol
@@ -1014,11 +1083,70 @@ function isCreateRequireBinding7(program, callee) {
         : undefined;
     if (decl === undefined ||
         decl.initializer === undefined ||
-        !ts.isVariableDeclarationList(decl.parent) ||
-        (decl.parent.flags & ts.NodeFlags.Const) === 0) {
+        !ts.isVariableDeclarationList(decl.parent)) {
         return false;
     }
-    const init = stripRequireCasts7(decl.initializer);
+    return isCreateRequireBaseCall7(program, decl.initializer) && ((decl.parent.flags & ts.NodeFlags.Const) !== 0 ||
+        stableCreateRequireBindingReason7(program, decl) === null);
+}
+/** Only literal calls and literal resolution queries can erase the loader
+ * value. In particular, assignments, exported aliases, shorthand properties,
+ * optional calls, and passing the loader to user code cannot pass this test. */
+function staticCreateRequireUse7(expr) {
+    let use = expr;
+    while (ts.isParenthesizedExpression(use.parent))
+        use = use.parent;
+    if (ts.isPropertyAccessExpression(use.parent) && use.parent.expression === use && use.parent.name.text === "resolve" && !use.parent.questionDotToken) {
+        use = use.parent;
+        if (ts.isPropertyAccessExpression(use.parent) && use.parent.expression === use && use.parent.name.text === "paths" && !use.parent.questionDotToken)
+            use = use.parent;
+    }
+    const call = use.parent;
+    return ts.isCallExpression(call) && call.expression === use && !call.questionDotToken &&
+        call.arguments.length === 1 && ts.isStringLiteralLike(call.arguments[0]);
+}
+function stableCreateRequireBindingReason7(program, decl) {
+    const cache = program.analysis.createRequireReasons;
+    if (cache.has(decl))
+        return cache.get(decl);
+    const check = () => {
+        const stmt = decl.parent?.parent;
+        if (!ts.isIdentifier(decl.name) || !ts.isVariableStatement(stmt) || !ts.isSourceFile(stmt.parent)) {
+            return "its mutable createRequire binding is outside the module's top level";
+        }
+        const checker = program.getTypeChecker();
+        const symbol = checker.getSymbolAtLocation(decl.name);
+        if (!symbol || checker.declarationsOf(symbol).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 refs = identifierOccurrences7(sf, decl.name.text);
+        checker.prefetchSymbolNodesExact(refs);
+        for (const ref of refs) {
+            if (ref === decl.name || inTypePosition7(ref))
+                continue;
+            let target = ts.isShorthandPropertyAssignment(ref.parent)
+                ? checker.getShorthandAssignmentValueSymbol(ref.parent)
+                : checker.getSymbolAtLocation(ref);
+            if (target && (target.flags & ts.SymbolFlags.Alias) !== 0)
+                target = checker.getAliasedSymbol(target);
+            if (target === symbol && !staticCreateRequireUse7(ref)) {
+                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) {
+            return "its createRequire binding can be used before initialization";
+        }
+        return null;
+    };
+    const reason = check();
+    cache.set(decl, reason);
+    return reason;
+}
+function isCreateRequireBaseCall7(program, expr) {
+    const init = stripRequireCasts7(expr);
     if (!ts.isCallExpression(init) ||
         init.questionDotToken !== undefined ||
         !ts.isIdentifier(init.expression) ||
@@ -1028,13 +1156,77 @@ function isCreateRequireBinding7(program, callee) {
     }
     const base = stripRequireCasts7(init.arguments[0]);
     if (ts.isIdentifier(base) && base.text === "__filename")
-        return true;
+        return !sourceBinding7(program, base);
     return (ts.isPropertyAccessExpression(base) &&
         base.questionDotToken === undefined &&
         ts.isMetaProperty(base.expression) &&
         base.expression.keywordToken === ts.SyntaxKind.ImportKeyword &&
         (base.name.text === "url" || base.name.text === "filename"));
 }
+/** A node:module import alone does not require an engine. Retain npm
+ * fallback for require indirection the lowering cannot erase, while
+ * admitting literal calls through the same stable/inline shapes as program
+ * code. Inspect symbols, not names: nested shadows are unrelated bindings. */
+function npmStaticModuleImportReason7(program, stmt) {
+    const clause = stmt.importClause;
+    if (!clause)
+        return null;
+    const bindings = clause.namedBindings;
+    if (clause.name || (bindings && !ts.isNamedImports(bindings))) {
+        return "its node:module namespace or default import has no static createRequire usage proof";
+    }
+    if (!bindings || !ts.isNamedImports(bindings))
+        return null;
+    const checker = program.getTypeChecker();
+    const sf = stmt.getSourceFile();
+    for (const specifier of bindings.elements) {
+        if ((specifier.propertyName?.text ?? specifier.name.text) !== "createRequire")
+            continue;
+        const imported = checker.getSymbolAtLocation(specifier.name);
+        if (!imported)
+            return "its createRequire import could not be resolved";
+        checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, specifier.name.text));
+        let reason = null;
+        const checkUse = (expr) => {
+            if (!staticCreateRequireUse7(expr)) {
+                reason = "its createRequire result escapes or is used with a computed specifier (static requires need literal specifiers)";
+            }
+        };
+        ts.walkPreorder(sf, (node) => {
+            if (reason || !ts.isIdentifier(node) || node.text !== specifier.name.text || node === specifier.name || checker.getSymbolAtLocation(node) !== imported)
+                return;
+            const call = node.parent;
+            if (!ts.isCallExpression(call) || call.expression !== node || !isCreateRequireBaseCall7(program, call)) {
+                reason = "its createRequire import is used outside a supported call based on the current file";
+                return;
+            }
+            const decl = call.parent;
+            if (ts.isVariableDeclaration(decl) && decl.initializer === call && ts.isIdentifier(decl.name)) {
+                if ((ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Export) !== 0) {
+                    reason = "its createRequire result escapes through an exported binding";
+                    return;
+                }
+                if (!isCreateRequireBinding7(program, decl.name)) {
+                    reason = stableCreateRequireBindingReason7(program, decl);
+                    return;
+                }
+                const sym = checker.getSymbolAtLocation(decl.name);
+                const name = decl.name.text;
+                checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, name));
+                ts.walkPreorder(sf, (ref) => {
+                    if (ts.isIdentifier(ref) && ref.text === name && ref !== decl.name && checker.getSymbolAtLocation(ref) === sym)
+                        checkUse(ref);
+                });
+            }
+            else {
+                checkUse(call);
+            }
+        });
+        if (reason)
+            return reason;
+    }
+    return null;
+}
 /** Classifies a require-shaped call as Node's ambient CommonJS global, the
  * one supported createRequire source binding, or another source binding.
  * The scanners still collect createRequire calls because they carry static
@@ -1119,9 +1311,11 @@ function nodeEsmSyntaxMarker7(sf) {
             found = node;
             return "stop";
         }
-        if (!insideFunctionLike7(node) &&
-            (ts.isAwaitExpression(node) ||
-                (ts.isForOfStatement(node) && node.awaitModifier !== undefined))) {
+        // Only await syntax needs an ancestor walk. Doing this for every node
+        // makes a deeply nested expression take quadratic time to classify.
+        if ((ts.isAwaitExpression(node) ||
+            (ts.isForOfStatement(node) && node.awaitModifier !== undefined)) &&
+            !insideFunctionLike7(node)) {
             found = node;
             return "stop";
         }
@@ -1129,14 +1323,13 @@ function nodeEsmSyntaxMarker7(sf) {
     });
     return found;
 }
-const nodeEsmFileCache7 = new WeakMap();
 /** True when Node would treat this file as an ES MODULE (never defining
  * require/__dirname there): fixed extensions first, then an explicit
  * nearest-package type, then Node's syntax markers for ambiguous .js/.ts
  * files. TypeScript's external-module bit is forced for checker scoping and
  * therefore intentionally plays no part in this runtime decision. */
-function isNodeEsmFile7(sf) {
-    const cached = nodeEsmFileCache7.get(sf);
+function isNodeEsmFile7(sf, program) {
+    const cached = program?.analysis.nodeEsmFiles.get(sf);
     if (cached !== undefined)
         return cached;
     let result;
@@ -1154,21 +1347,21 @@ function isNodeEsmFile7(sf) {
                 ? false
                 : nodeEsmSyntaxMarker7(sf) !== null;
     }
-    nodeEsmFileCache7.set(sf, result);
+    program?.analysis.nodeEsmFiles.set(sf, result);
     return result;
 }
 /** A JavaScript source file Node treats as CommonJS (not an ES module):
  * ESM namespace/default machinery must not claim it — its export surface
  * is module.exports, read through the CJS interop paths and their own
  * fences. */
-function isCjsJsFile7(sf) {
-    return isJsSourceFileName(sf.fileName) && !isNodeEsmFile7(sf);
+function isCjsJsFile7(sf, program) {
+    return isJsSourceFileName(sf.fileName) && !isNodeEsmFile7(sf, program);
 }
 /** The exported spelling of isCjsJsFile7 (the lowering's gate for
  * module.exports surfaces — `ts.isExternalModule` is NOT the CJS test:
  * tsgo marks CJS files with export assignments as external modules). */
-export function isCjsJsFile(sf) {
-    return isCjsJsFile7(sf);
+export function isCjsJsFile(sf, program) {
+    return isCjsJsFile7(sf, program);
 }
 /** The self-import TDZ fences: for `import { x } from "<self>"` (default
  * and namespace forms included), any TOP-LEVEL reference lexically above
@@ -1578,7 +1771,7 @@ function identifierOccurrences7(root, text) {
  * Re-export statements bind nothing locally — always null: the alias is
  * link-time plumbing, never an evaluation-time read. Export specifiers
  * of an imported binding are the same alias story, not reads. */
-function backEdgeUseOffence7(program, sf, stmt) {
+function backEdgeUseOffence7(program, stmt, occurrences) {
     if (!ts.isImportDeclaration(stmt) || stmt.importClause === undefined)
         return null;
     const checker = program.getTypeChecker();
@@ -1598,25 +1791,16 @@ function backEdgeUseOffence7(program, sf, stmt) {
         const sym = checker.getSymbolAtLocation(bindingName);
         if (sym === undefined)
             continue;
-        checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, bindingName.text));
-        let offence = null;
-        const visit = (node) => {
-            if (offence !== null || ts.isImportDeclaration(node))
-                return;
-            if (ts.isIdentifier(node) &&
-                node.text === bindingName.text &&
-                !(node.parent !== undefined && ts.isExportSpecifier(node.parent)) &&
+        const references = occurrences.get(bindingName.text) ?? [];
+        checker.prefetchSymbolNodesExact(references);
+        for (const node of references) {
+            if (!(node.parent !== undefined && ts.isExportSpecifier(node.parent)) &&
                 checker.getSymbolAtLocation(node) === sym &&
                 !inTypePosition7(node) &&
                 !inDeferredPosition7(node)) {
-                offence = { name: bindingName.text, node };
-                return;
+                return { name: bindingName.text, node };
             }
-            ts.forEachChild(node, visit);
-        };
-        visit(sf);
-        if (offence !== null)
-            return offence;
+        }
     }
     return null;
 }
@@ -1687,6 +1871,30 @@ export function makeCycleAdmission(program, edgesOf) {
     // reason the cluster's cycles stay fenced, or null when its every
     // member passes the inert-top-level bar.
     const sccVerdict = new Map();
+    // A module can close many cycle edges, each importing many bindings.
+    // Index its identifiers once for this admission pass. ASTs are immutable;
+    // the pass owns the index so it cannot retain a disposed program.
+    const bindingUses = new Map();
+    const usesOf = (sf) => {
+        const cached = bindingUses.get(sf);
+        if (cached !== undefined)
+            return cached;
+        const uses = new Map();
+        ts.walkPreorder(sf, (node) => {
+            if (ts.isImportDeclaration(node))
+                return "skip";
+            if (ts.isIdentifier(node)) {
+                const references = uses.get(node.text);
+                if (references !== undefined)
+                    references.push(node);
+                else
+                    uses.set(node.text, [node]);
+            }
+            return undefined;
+        });
+        bindingUses.set(sf, uses);
+        return uses;
+    };
     return (importer, e) => {
         if (e.stmt === undefined)
             return "the cycle closes through a require() edge";
@@ -1710,7 +1918,7 @@ export function makeCycleAdmission(program, edgesOf) {
         if (!sccVerdict.has(comp)) {
             let reason = null;
             for (const m of comp) {
-                if (isCjsJsFile7(m)) {
+                if (isCjsJsFile7(m, program)) {
                     reason = `${m.fileName} is a CommonJS module — admission covers ES-module cycles only`;
                     break;
                 }
@@ -1723,9 +1931,11 @@ export function makeCycleAdmission(program, edgesOf) {
             sccVerdict.set(comp, reason);
         }
         const clusterReason = sccVerdict.get(comp);
+        if (clusterReason === undefined)
+            throw new Error("missing module-cycle verdict");
         if (clusterReason !== null)
             return clusterReason;
-        const use = backEdgeUseOffence7(program, importer, e.stmt);
+        const use = backEdgeUseOffence7(program, e.stmt, usesOf(importer));
         if (use !== null) {
             return `the cycle-crossing binding '${use.name}' is read at ${lineOf(use.node)}, outside any function body — a read during the init window observes the partially-initialized module (Node's TDZ ReferenceError / stale var), which is not modeled`;
         }
@@ -1736,18 +1946,20 @@ export function makeCycleAdmission(program, edgesOf) {
  * program, or null (unresolvable / outside the program). Exported (as
  * resolveImport) for the lowering: CommonJS require statements lower to
  * guarded %init calls of exactly the module preflight resolved here. */
-function resolveImport7(program, from, specifier) {
+function resolveImport7(program, from, specifier, resolutionKind = "import") {
     const resolved = resolveProjectModule(from.fileName, specifier);
-    if (resolved === null)
-        return null;
-    return program.getSourceFile(resolved) ?? null;
+    if (resolved !== null)
+        return program.getSourceFile(resolved) ?? null;
+    const npm = resolveNpmImport7(from.fileName, specifier, resolutionKind);
+    return npm && isNpmStaticPackage(npm.packageName)
+        ? npmStaticProgramDep(program, npm.packageName, npm.typesFile) : null;
 }
 /** An import that resolves into node_modules: the package's shipped .d.ts
  * is the type surface, and the package's shipped JS runs in the dynamic
  * island under --dynamic. Resolution rides the own resolver (resolve.ts).
  * Null for relative and node: specifiers, and for anything that doesn't
  * resolve into node_modules. */
-function resolveNpmImport7(fromFileName, specifier) {
+function resolveNpmImport7(fromFileName, specifier, resolutionKind = "import") {
     if (isRelativeSpecifier(specifier) || specifier.startsWith("node:")) {
         return null;
     }
@@ -1756,7 +1968,7 @@ function resolveNpmImport7(fromFileName, specifier) {
     // answers the entry), so no island embed and no .d.ts type surface.
     if (provenanceEntryFor(specifier) !== null)
         return null;
-    const resolved = resolveBareModule(fromFileName, specifier);
+    const resolved = resolveBareModule(fromFileName, specifier, undefined, resolutionKind);
     if (!resolved)
         return null;
     if (!isNodeModulesPath(resolved.typesFile)) {
@@ -1831,24 +2043,16 @@ function processModuleAliasImport7(spec, stmt) {
     return clause !== undefined && clause.name !== undefined && clause.namedBindings === undefined;
 }
 /** The whole TS7-lane lifecycle for one entry: spawn (or share) a tsgo
- * host, build the lowering-world program, run the ported preflight, and
- * dispose EVERYTHING before returning — the CLI process must exit promptly,
- * so no snapshot or tsgo child outlives the call. */
-export function checkPreflightTs7(entryPath, sharedHost) {
-    const host = sharedHost ?? new ts.Ts7Host({ cwd: dirname(entryPath) });
+ * host, build the lowering-world program, run preflight, and release its
+ * snapshot. The caller owns the supplied host and can reuse or close it. */
+export function checkPreflightTs7(entryPath, host) {
+    const load = loadProgram7(host, resolve(entryPath));
     try {
-        const load = loadProgram7(host, entryPath);
-        try {
-            const { diags, moduleOrder } = preflight7(load);
-            return { diags, moduleOrder: moduleOrder.map((sf) => sf.fileName) };
-        }
-        finally {
-            load.disposeAll();
-        }
+        const { diags, moduleOrder } = preflight7(load);
+        return { diags, moduleOrder: moduleOrder.map((sf) => sf.fileName) };
     }
     finally {
-        if (!sharedHost)
-            host.close();
+        load.disposeAll();
     }
 }
 function preflight7(load) {
@@ -2062,6 +2266,8 @@ function preflight7(load) {
             !npmStaticFileSuppressed(d) &&
             !nodeModulesJsSuppressed(d) &&
             !namespaceCalleeSuppressed(p, d) &&
+            !inferredJsDiagnosticSuppressed(p, d) &&
+            !isNpmStaticSubclassArgument(p, d) &&
             !workspaceImplicitAnySuppressed(p, d) &&
             !jsdocTypeSuppressed(p, d, commentDup));
     };
@@ -2097,7 +2303,7 @@ function preflight7(load) {
         (!isNodeModulesPath(sf.fileName) || entryPackageFile(sf.fileName) || npmStaticPackageOfPath(sf.fileName) !== null) &&
         !islandJsFile(sf.fileName));
     const userFiles = npmStaticActive()
-        ? planNpmStaticReexports(program, entry, programFiles, [...createRequireProgramRoots7(program), ...forkTargetPaths(program, program.getSourceFiles())], (sf, spec) => resolveImport7(program, sf, spec) ?? npmStaticDepSf7(program, sf, spec))
+        ? planNpmStaticReexports(program, entry, programFiles, [...createRequireProgramRoots7(program), ...forkTargetPaths(program, program.getSourceFiles())], (sf, spec, resolutionKind) => resolveImport7(program, sf, spec, resolutionKind) ?? npmStaticDepSf7(program, sf, spec, resolutionKind))
         : programFiles;
     program.getTypeChecker().prefetchSourceFileStructures(userFiles);
     // node_modules JS that no --npm-static opt-in claims is NOT program
@@ -2121,7 +2327,7 @@ function preflight7(load) {
             }
             continue;
         }
-        if (!isNodeEsmFile7(sf)) {
+        if (!isNodeEsmFile7(sf, program)) {
             const marker = nodeEsmSyntaxMarker7(sf);
             if (marker !== null)
                 diags.push(commonJsModuleSyntaxDiag(locOf7(marker)));
@@ -2259,7 +2465,7 @@ function preflight7(load) {
                 // RESOLVED user module lowers; everything else keeps the fence —
                 // there is no namespace object to materialize.
                 if (stmt.exportClause && ts.isNamespaceExport(stmt.exportClause)) {
-                    if (reDep === null || reDep.fileName.endsWith(".json") || isCjsJsFile7(reDep)) {
+                    if (reDep === null || reDep.fileName.endsWith(".json") || isCjsJsFile7(reDep, program)) {
                         diags.push(unsupportedDiag("SC1013", locOf7(stmt), "namespace re-exports (export * as ns) of this module form"));
                         continue;
                     }
@@ -2290,17 +2496,15 @@ function preflight7(load) {
             }
             const isRelative = isRelativeSpecifier(spec);
             const isBare = !isRelative && !ambientModules.has(spec);
-            // --npm-static: an opted-in package importing node:module admits
-            // for PROGRAM code (per-member fences, divergence 370) but marks
-            // the PACKAGE an offender — createRequire's static story covers
-            // only literal-specifier requires, and bundler banners (esbuild's
-            // __createRequire(import.meta.url) prologue) feed the returned
-            // require COMPUTED specifiers at module INIT, so a static compile
-            // would fence at load where the island runs the package as shipped.
+            // Npm packages can use the same static createRequire forms as program
+            // code. Preserve fallback for bundler banners that pass the require
+            // value around or feed it computed specifiers during initialization.
             if (canonicalBuiltinModule(spec) === "module") {
                 const pkg = npmStaticPackageOfPath(sf.fileName);
                 if (pkg !== null) {
-                    reportNpmStaticOffender(pkg, "it imports node:module (bundler banners drive createRequire's require with computed specifiers; the island serves the package)");
+                    const reason = npmStaticModuleImportReason7(program, stmt);
+                    if (reason !== null)
+                        reportNpmStaticOffender(pkg, reason);
                 }
             }
             // An import edge Node's own resolution refuses BEFORE any module
@@ -2452,7 +2656,7 @@ function preflight7(load) {
                     if (isJson) {
                         diags.push(unsupportedDiag("SC1013", locOf7(clause.namedBindings), "namespace imports of JSON modules"));
                     }
-                    else if (dep !== null && isCjsJsFile7(dep)) {
+                    else if (dep !== null && isCjsJsFile7(dep, program)) {
                         // A CJS namespace binding whose every use is a bare expression
                         // statement (`cjs;` — the corpus's "the import linked"
                         // assertion) carries no surface question: the statement lowers
@@ -2494,7 +2698,7 @@ function preflight7(load) {
                     // files keep the full CommonJS scan.
                     if (!jsRequireFile && bindingKind !== "createRequire")
                         continue;
-                    if (isNodeEsmFile7(sf)) {
+                    if (isNodeEsmFile7(sf, program)) {
                         if (bindingKind !== "createRequire") {
                             diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
                             continue;
@@ -2515,14 +2719,14 @@ function preflight7(load) {
                         }
                     }
                     const isRelative = isRelativeSpecifier(req.spec);
-                    let dep = resolveImport7(program, sf, req.spec);
+                    let dep = resolveImport7(program, sf, req.spec, "require");
                     if (dep === null && !isRelative) {
                         // --npm-static: a require() of an OPTED-IN package is a
                         // program-module edge exactly like the import-declaration
                         // form above (bundle dists require their workspace siblings —
                         // the same resolution, the same offender discipline on a
                         // miss).
-                        const npmReq = !req.spec.startsWith("#") ? resolveNpmImport7(sf.fileName, req.spec) : null;
+                        const npmReq = !req.spec.startsWith("#") ? resolveNpmImport7(sf.fileName, req.spec, "require") : null;
                         if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
                             dep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
                             if (dep === null)
@@ -2566,7 +2770,7 @@ function preflight7(load) {
                     const prefixCanRun = (firstRunnable >= 0 && firstRunnable < k) ||
                         precedingDecls.some((decl) => !purePrefixDecl7(decl));
                     const tdzName = prefixCanRun && req.decl
-                        ? requireTdzRisk7(program, sf, k, req.decl, precedingDecls)
+                        ? 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)`));
@@ -2584,7 +2788,7 @@ function preflight7(load) {
                 const bindingKind = requireCallBindingKind7(program, call);
                 if (!jsRequireFile && bindingKind !== "createRequire")
                     continue;
-                if (isNodeEsmFile7(sf)) {
+                if (isNodeEsmFile7(sf, program)) {
                     if (bindingKind !== "createRequire") {
                         diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
                         continue;
@@ -2593,7 +2797,7 @@ function preflight7(load) {
                 if (load.externalTypes.has(spec)) {
                     continue;
                 }
-                const projectDep = resolveImport7(program, sf, spec);
+                const projectDep = resolveImport7(program, sf, spec, "require");
                 if (projectDep !== null) {
                     if (projectDep.fileName.endsWith(".json")) {
                         if (bindingKind === "createRequire")
@@ -2607,7 +2811,7 @@ function preflight7(load) {
                 if (!isRelativeSpecifier(spec)) {
                     // --npm-static: opted-in packages ride the program-module edge
                     // (the statement-level require branch above).
-                    const npmReq = !spec.startsWith("#") ? resolveNpmImport7(sf.fileName, spec) : null;
+                    const npmReq = !spec.startsWith("#") ? resolveNpmImport7(sf.fileName, spec, "require") : null;
                     if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
                         const nDep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
                         if (nDep !== null)
@@ -2756,19 +2960,19 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
     // Reexport targets union in only when they resolve to CommonJS program
     // files (Node's cjsPreparseModuleExports rule).
     const resolveCjsDep = (from, spec) => {
-        const dep = resolveEdge(from, spec);
-        return dep !== null && isCjsJsFile7(dep) ? dep : null;
+        const dep = resolveImport7(program, from, spec, "require") ?? npmStaticDepSf7(program, from, spec, "require");
+        return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
     };
     const visible = (dep, name) => 
     // `default` is the module.exports binding itself — always provided.
-    // (cjs-lexer.ts lexes SOURCE TEXT — only strings cross into the
-    // typescript5 island; the SourceFile is just the memo/resolve handle.)
-    name === "default" || cjsLexerVisibleNames(dep, (d) => d.text, resolveCjsDep, lexMemo).has(name);
+    // 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);
     /** The statement's resolved LOCAL CommonJS dependency, when it is an
      * import/re-export from one. */
     const cjsDepOf = (sf, spec) => {
         const dep = resolveEdge(sf, spec);
-        return dep !== null && isCjsJsFile7(dep) ? dep : null;
+        return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
     };
     /** The first lexer-invisible CJS name request of ONE module, in V8's
      * check order: all regular named imports sorted by local binding name,
@@ -2841,7 +3045,7 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
                 continue;
             const spec = specNode.text;
             const dep = resolveEdge(sf, spec);
-            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep))
+            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program))
                 continue;
             const bad = dfs(dep);
             if (bad !== null)
@@ -2849,12 +3053,12 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
         }
         return firstInvisibleOf(sf);
     };
-    const bad = isNodeEsmFile7(entry) ? dfs(entry) : null;
+    const bad = isNodeEsmFile7(entry, program) ? dfs(entry) : null;
     // ESM modules only require() reaches: same invisibility, but Node's
     // SyntaxError fires mid-evaluation at the require — a pointed fence
     // instead of a mismodeled crash position.
     for (const sf of moduleOrder) {
-        if (!isNodeEsmFile7(sf) || visited.has(sf))
+        if (!isNodeEsmFile7(sf, program) || visited.has(sf))
             continue;
         const b = firstInvisibleOf(sf);
         if (b !== null) {
@@ -2970,7 +3174,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
             if (stmt.moduleSpecifier === undefined || !ts.isStringLiteral(stmt.moduleSpecifier))
                 continue;
             const target = resolveEdge(dep, stmt.moduleSpecifier.text);
-            if (target === null || target.fileName.endsWith(".json") || !isNodeEsmFile7(target))
+            if (target === null || target.fileName.endsWith(".json") || !isNodeEsmFile7(target, program))
                 continue;
             const candidate = runtimeExport(target, name, nextSeen);
             if (candidate === undefined)
@@ -2991,7 +3195,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
                 continue;
             const spec = stmt.moduleSpecifier.text;
             const dep = resolveEdge(sf, spec);
-            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep))
+            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program))
                 continue;
             if (clause.name !== undefined) {
                 imports.push({ local: clause.name.text, exportName: "default", spec, nameNode: clause.name, dep });
@@ -3036,7 +3240,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
                 continue;
             const spec = moduleSpecifier.text;
             const dep = resolveEdge(sf, spec);
-            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep))
+            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program))
                 continue;
             for (const element of exportClause.elements) {
                 if (element.isTypeOnly)
@@ -3068,7 +3272,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
             if (moduleSpecifier === undefined || !ts.isStringLiteral(moduleSpecifier))
                 continue;
             const dep = resolveEdge(sf, moduleSpecifier.text);
-            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep))
+            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program))
                 continue;
             const bad = dfs(dep);
             if (bad !== null)
@@ -3079,7 +3283,7 @@ function analyzeEsmNamedImportLinks(program, entry) {
     // Native ESM linking itself starts only from an ESM entry. The caller
     // supplies dynamic-only roots here too; each such root gets its own
     // promise rejection rather than a startup crash.
-    const bad = isNodeEsmFile7(entry) ? dfs(entry) : null;
+    const bad = isNodeEsmFile7(entry, program) ? dfs(entry) : null;
     if (bad !== null) {
         return {
             crash: {
@@ -3106,7 +3310,7 @@ function esmNamedImportLinkCheck(program, entry, moduleOrder, diags) {
     // before earlier output). Keep the compile-time fence used by the CJS link
     // checker for the analogous mid-evaluation failure instead.
     for (const sf of moduleOrder) {
-        if (!isNodeEsmFile7(sf) || analysis.visited.has(sf))
+        if (!isNodeEsmFile7(sf, program) || analysis.visited.has(sf))
             continue;
         const childFailure = analysis.firstMissingOf(sf);
         if (childFailure !== null) {
@@ -3274,12 +3478,12 @@ export function orderedImportsOf(program, sf) {
  * as a module edge), else null. No offender reporting here — preflight
  * already classified the import; this is the lookup the module-order and
  * lowering paths share. */
-export function npmStaticDepSf7(program, sf, spec) {
+export function npmStaticDepSf7(program, sf, spec, resolutionKind = "import") {
     if (!npmStaticActive() || isRelativeSpecifier(spec))
         return null;
     if (spec.startsWith("node:") || spec.startsWith("#"))
         return null;
-    const npm = resolveNpmImport7(sf.fileName, spec);
+    const npm = resolveNpmImport7(sf.fileName, spec, resolutionKind);
     if (npm === null || !isNpmStaticPackage(npm.packageName))
         return null;
     if (!isJsSourceFileName(npm.typesFile))