@scriptc/compiler 0.1.1 → 0.1.2

package/dist/frontend/program.js

@@ -39,19 +39,20 @@
  *    JSON.parse's wording rather than tsc's, the one message-text delta on
  *    that path (no snapshot pins it). */
 import { builtinModules } from "node:module";
-import { dirname, resolve } from "node:path";
+import { dirname, isAbsolute, resolve } from "node:path";
 import * as ts from "./ts7/adapter.js";
 import { commonJsModuleSyntaxDiag, invalidPackageConfigDiag, strictNullChecksFloorDiag, tscPassthroughDiag, unsupportedDiag, } from "../diagnostics/diagnostic.js";
-import { isNodeModulesPath, nearestInvalidPackageJsonPath, nearestPackageType, nearestPkgJsonPath, projectDtsRuntimeSibling, resolveBareModule, resolveProjectImport, resolveRelativeModule, resolveTypeDirective, setProjectRealm } from "./resolve.js";
+import { isNodeModulesPath, nearestInvalidPackageJsonPath, nearestPackageType, nearestPkgJsonPath, projectDtsRuntimeSibling, resolveBareModule, resolveProjectModule, resolveTypeDirective, setProjectPathMappings, setProjectRealm } from "./resolve.js";
 import { probeNodeImportRefusal, probeNodeRequireRefusal } from "./npm.js";
-import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticPackages } from "./npm-static.js";
+import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticDeclarationOverloads, setNpmStaticPackages } from "./npm-static.js";
+import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties } from "./npm-static-declarations.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
 import { cjsLexerVisibleNames } from "./cjs-lexer.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, registerWorkspacePackage, workspacePackageOfPath, } from "./workspace-registry.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 } from "./input-tracker.js";
+import { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
 const BASE_OPTIONS = {
     strict: true,
 };
@@ -67,7 +68,10 @@ const FORCED_OPTIONS = {
     // classification is intentionally independent below; this option is only
     // the binder's scope decision.
     moduleDetection: ts.ModuleDetectionKind.Force,
-    lib: ["lib.es2025.d.ts"],
+    // Explicit resource management is an ESNext library slice in TS 7 even
+    // though Node 24 ships the runtime protocol. Include that focused lib
+    // without widening the rest of the standard-library target past ES2025.
+    lib: ["lib.es2025.d.ts", "lib.esnext.disposable.d.ts"],
     types: [],
     allowImportingTsExtensions: true,
     allowJs: true,
@@ -142,6 +146,28 @@ function adoptProjectConfig7(host, entryPath) {
         if (value !== undefined)
             adopted[key] = value;
     }
+    // TS 7 accepts `paths`, but no longer accepts `baseUrl` as a compiler
+    // option. Translate the established baseUrl+paths spelling into absolute
+    // targets: the synthesized config lives beside the entry rather than the
+    // real config, so preserving relative targets would silently change their
+    // meaning. The absolute map is also the own resolver's configuration.
+    const rawPaths = parsed.options["paths"];
+    if (rawPaths !== undefined && typeof rawPaths === "object" && rawPaths !== null) {
+        const configDir = dirname(configFile);
+        const rawBaseUrl = parsed.options["baseUrl"];
+        const base = typeof rawBaseUrl === "string"
+            ? (isAbsolute(rawBaseUrl) ? rawBaseUrl : resolve(configDir, rawBaseUrl))
+            : configDir;
+        const paths = {};
+        for (const [key, targets] of Object.entries(rawPaths)) {
+            if (!Array.isArray(targets))
+                continue;
+            paths[key] = targets
+                .filter((target) => typeof target === "string")
+                .map((target) => isAbsolute(target) ? target : resolve(base, target));
+        }
+        adopted["paths"] = paths;
+    }
     const nullChecks = adopted["strictNullChecks"] ?? adopted["strict"] ?? false;
     if (nullChecks !== true) {
         diags.push(strictNullChecksFloorDiag(configFile));
@@ -156,6 +182,94 @@ function resolveNodeTypes7(entryPath) {
     const file = resolveTypeDirective("node", entryPath);
     return file !== null && isNodeTypesPath(file) ? file : null;
 }
+function declarationReexportTarget(fromFile, specifier) {
+    const base = resolve(dirname(fromFile), specifier);
+    const candidates = [];
+    const extension = /\.(mjs|cjs|js)$/.exec(base)?.[1];
+    if (extension !== undefined) {
+        const stem = base.slice(0, -(extension.length + 1));
+        if (extension === "mjs")
+            candidates.push(`${stem}.d.mts`, `${stem}.d.ts`);
+        else if (extension === "cjs")
+            candidates.push(`${stem}.d.cts`, `${stem}.d.ts`);
+        else
+            candidates.push(`${stem}.d.ts`, `${stem}.d.mts`, `${stem}.d.cts`);
+    }
+    else {
+        candidates.push(base, `${base}.d.ts`, `${base}.d.mts`, `${base}.d.cts`);
+    }
+    candidates.push(resolve(base, "index.d.ts"), resolve(base, "index.d.mts"), resolve(base, "index.d.cts"));
+    return candidates.find((candidate) => trackedFileExists(candidate)) ?? null;
+}
+function runtimeReexportTarget(fromFile, specifier) {
+    const base = resolve(dirname(fromFile), specifier);
+    const candidates = [
+        base,
+        `${base}.js`,
+        `${base}.mjs`,
+        `${base}.cjs`,
+        resolve(base, "index.js"),
+        resolve(base, "index.mjs"),
+        resolve(base, "index.cjs"),
+    ];
+    const target = candidates.find((candidate) => trackedFileExists(candidate) && isJsSourceFileName(candidate));
+    return target === undefined ? null : (trackedRealpath(target) ?? target);
+}
+/** 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) {
+    const seen = new Set();
+    const packageJson = nearestPkgJsonPath(entryPath);
+    const packageRoot = (packageJson === null ? dirname(entryPath) : dirname(packageJson)).split("\\").join("/");
+    const visit = (path) => {
+        path = resolve(path);
+        const normalized = path.split("\\").join("/");
+        if (normalized !== packageRoot && !normalized.startsWith(packageRoot + "/"))
+            return;
+        if (seen.has(path))
+            return;
+        seen.add(path);
+        const source = trackedReadFile(path);
+        if (source === null)
+            return;
+        onSource(path, source);
+        for (const specifier of npmStaticDeclarationReexports(path, source)) {
+            const target = declarationReexportTarget(path, specifier);
+            if (target !== null)
+                visit(target);
+        }
+    };
+    visit(entryPath);
+}
+function npmStaticDeclarationOverloadsOf(entryPath) {
+    const classes = new Map();
+    visitNpmStaticDeclarationClosure(entryPath, (path, source) => {
+        for (const [className, methods] of parseNpmStaticDeclarationOverloads(path, source)) {
+            const target = classes.get(className) ?? new Map();
+            classes.set(className, target);
+            for (const [methodName, signatures] of methods) {
+                if (!target.has(methodName))
+                    target.set(methodName, signatures);
+            }
+        }
+    });
+    return classes;
+}
+function npmStaticDeclarationPropertiesOf(entryPath) {
+    const classes = new Map();
+    visitNpmStaticDeclarationClosure(entryPath, (path, source) => {
+        for (const [className, properties] of parseNpmStaticDeclarationProperties(path, source)) {
+            const target = classes.get(className) ?? new Map();
+            classes.set(className, target);
+            for (const [propertyName, type] of properties) {
+                if (!target.has(propertyName))
+                    target.set(propertyName, type);
+            }
+        }
+    });
+    return classes;
+}
 /** True when a coverage mapping names one exact bare host module. TypeScript
  * gives `paths` keys containing `*` pattern semantics, so accepting one here
  * would silently broaden the mapping beyond the specifier the caller named. */
@@ -232,6 +346,10 @@ function externalTypeFileClosure7(program, externalTypes) {
 }
 function loadProgram7(host, entryPath, externalTypes = new Map()) {
     const config = adoptProjectConfig7(host, entryPath);
+    const configuredPaths = config.options["paths"];
+    setProjectPathMappings(configuredPaths !== undefined && typeof configuredPaths === "object" && configuredPaths !== null
+        ? configuredPaths
+        : null);
     const nodeTypes = config.configFile ? resolveNodeTypes7(entryPath) : null;
     // skipLibCheck is FORCED with @types/node in the program: checking a
     // third-party lib's internals against OUR lib choice (es2025, no dyn) is
@@ -251,7 +369,10 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
     // driver against the package's real TypeScript, not its shipped .d.ts.
     const provenance = provenancePaths();
     if (provenance !== null || externalTypes.size > 0) {
-        const paths = { ...(provenance ?? {}) };
+        const paths = {
+            ...configuredPaths,
+            ...(provenance ?? {}),
+        };
         for (const [specifier, declarationPath] of externalTypes) {
             paths[specifier] = [declarationPath];
         }
@@ -303,7 +424,60 @@ export function loadProgram(entryPath, opts) {
         }
         externalTypes.set(specifier, declarationPath);
     }
-    setNpmStaticPackages(opts?.npmStatic ?? []);
+    const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])];
+    // Resolve authored declaration entries before enabling the JS-only
+    // package resolver. Safe overload metadata binds through the runtime
+    // entry to one exact implementation file; it never contributes values
+    // or executable module edges.
+    const declarationOverloads = new Map();
+    const declarationProperties = new Map();
+    for (const pkg of npmStaticPackages) {
+        const resolved = resolveBareModule(entryPath, pkg, "types-only");
+        if (resolved === null ||
+            resolved.packageName !== pkg ||
+            !/\.d\.(?:ts|mts|cts)$/.test(resolved.typesFile)) {
+            continue;
+        }
+        const overloads = npmStaticDeclarationOverloadsOf(resolved.typesFile);
+        const properties = npmStaticDeclarationPropertiesOf(resolved.typesFile);
+        const classNames = new Set([...overloads.keys(), ...properties.keys()]);
+        if (classNames.size === 0)
+            continue;
+        const runtime = resolveBareModule(entryPath, pkg, "js-only");
+        if (runtime === null || !isJsSourceFileName(runtime.typesFile))
+            continue;
+        const runtimeSource = trackedReadFile(runtime.typesFile);
+        if (runtimeSource === null)
+            continue;
+        const targets = npmStaticRuntimeClassTargets(runtime.typesFile, runtimeSource, classNames);
+        for (const [className, specifier] of targets) {
+            const methods = overloads.get(className);
+            const fields = properties.get(className);
+            if (methods === undefined && fields === undefined)
+                continue;
+            const target = specifier === null ? runtime.typesFile : runtimeReexportTarget(runtime.typesFile, specifier);
+            if (target === null)
+                continue;
+            const targetPackage = npmPackageNameOf(target);
+            const targetNorm = target.split("\\").join("/");
+            const insideWorkspace = runtime.workspaceDir !== undefined &&
+                targetNorm.startsWith(runtime.workspaceDir.split("\\").join("/") + "/");
+            if (targetPackage !== pkg && !insideWorkspace)
+                continue;
+            if (methods !== undefined) {
+                const byClass = new Map(declarationOverloads.get(targetNorm) ?? []);
+                byClass.set(className, methods);
+                declarationOverloads.set(targetNorm, byClass);
+            }
+            if (fields !== undefined) {
+                const byClass = new Map(declarationProperties.get(targetNorm) ?? []);
+                byClass.set(className, fields);
+                declarationProperties.set(targetNorm, byClass);
+            }
+        }
+    }
+    setNpmStaticPackages(npmStaticPackages);
+    setNpmStaticDeclarationOverloads(declarationOverloads, declarationProperties);
     // Workspace-package registrations reset per load (same discipline as the
     // npm-static set), then the opted-in names are probed UP FRONT: a
     // workspace-linked opt-in resolves to files whose realpaths carry no
@@ -1327,7 +1501,7 @@ export function makeCycleAdmission(program, edgesOf) {
  * resolveImport) for the lowering: CommonJS require statements lower to
  * guarded %init calls of exactly the module preflight resolved here. */
 function resolveImport7(program, from, specifier) {
-    const resolved = resolveRelativeModule(from.fileName, specifier);
+    const resolved = resolveProjectModule(from.fileName, specifier);
     if (resolved === null)
         return null;
     return program.getSourceFile(resolved) ?? null;
@@ -1342,7 +1516,7 @@ function resolveNpmImport7(fromFileName, specifier) {
         return null;
     }
     // --provenance-sources: a registered specifier is NOT an npm import —
-    // its attested source compiles as program modules (resolveProjectImport
+    // its attested source compiles as program modules (resolveProjectModule
     // answers the entry), so no island embed and no .d.ts type surface.
     if (provenanceEntryFor(specifier) !== null)
         return null;
@@ -1888,9 +2062,15 @@ function preflight7(load) {
                     pos: stmt.getStart(sf),
                 });
             };
+            // Project modules win before npm fallback: this is the source graph
+            // tsgo type-checked for tsconfig paths, package imports/self-references,
+            // and provenance entries. Ordinary packages still answer null here.
+            const projDep = isBare ? resolveImport7(program, sf, spec) : null;
             // "#" specifiers can never name an npm package — they are the
-            // imports-field family, resolved below.
-            const npm = isBare && !spec.startsWith("#") ? resolveNpmImport7(sf.fileName, spec) : null;
+            // imports-field family, resolved by the project arm above.
+            const npm = isBare && projDep === null && !spec.startsWith("#")
+                ? resolveNpmImport7(sf.fileName, spec)
+                : null;
             if (npm && isNodeTypesPath(npm.typesFile)) {
                 diags.push(unsupportedDiag("SC1010", locOf7(stmt), unsupportedModuleFeatureOf(spec)));
                 continue;
@@ -1922,19 +2102,13 @@ function preflight7(load) {
                     continue;
                 }
             }
-            // PROJECT imports: package.json-mediated specifiers that resolve to
-            // the program's own sources — `#alias` (the imports field) and
-            // self-name references (the nearest package.json's name through its
-            // exports). A source answer is an ordinary user-module edge, exactly
-            // like a relative import (the checker resolved the bindings the same
-            // way); a refused resolution is Node's startup crash with Node's
-            // exact message; what keeps a compile fence: the unsupported
-            // builtin and the types-only resolution (Node-hostable or ambiguous
-            // — scriptc's own limitations, named as such).
-            let projDep = null;
+            // PROJECT imports: tsconfig paths and package.json-mediated specifiers
+            // that resolve to the program's own sources. A source answer is an
+            // ordinary user-module edge, exactly like a relative import (the
+            // checker resolved the bindings the same way); a refused resolution is
+            // Node's startup crash with Node's exact message; what keeps a compile
+            // fence is unsupported builtin or types-only surface.
             if (isBare && npmStaticDep === null) {
-                const resolved = resolveProjectImport(sf.fileName, spec);
-                projDep = resolved !== null ? (program.getSourceFile(resolved) ?? null) : null;
                 if (projDep !== null && projDep.isDeclarationFile) {
                     diags.push(unsupportedDiag("SC1010", locOf7(stmt), `the '${spec}' import (it resolves only to type declarations — there is no runtime implementation to compile)`));
                     continue;
@@ -2077,8 +2251,8 @@ function preflight7(load) {
                         }
                     }
                     const isRelative = isRelativeSpecifier(req.spec);
-                    let dep = null;
-                    if (!isRelative) {
+                    let dep = resolveImport7(program, sf, req.spec);
+                    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 —
@@ -2106,9 +2280,6 @@ function preflight7(load) {
                             continue;
                         }
                     }
-                    else {
-                        dep = resolveImport7(program, sf, req.spec);
-                    }
                     if (dep && dep.fileName.endsWith(".json")) {
                         diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
                         continue;
@@ -2139,6 +2310,15 @@ function preflight7(load) {
                 if (load.externalTypes.has(spec)) {
                     continue;
                 }
+                const projectDep = resolveImport7(program, sf, spec);
+                if (projectDep !== null) {
+                    if (projectDep.fileName.endsWith(".json")) {
+                        diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
+                        continue;
+                    }
+                    deps.push({ dep: projectDep });
+                    continue;
+                }
                 if (!isRelativeSpecifier(spec)) {
                     // --npm-static: opted-in packages ride the program-module edge
                     // (the statement-level require branch above).
@@ -2158,13 +2338,6 @@ function preflight7(load) {
                     }
                     continue;
                 }
-                const dep = resolveImport7(program, sf, spec);
-                if (dep && dep.fileName.endsWith(".json")) {
-                    diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
-                    continue;
-                }
-                if (dep)
-                    deps.push({ dep });
             }
         }
     }
@@ -2263,7 +2436,9 @@ function preflight7(load) {
             }
         }
     }
-    const linkCrash = resolveCrash !== null ? null : cjsNamedImportLinkCheck(program, entry, order, diags);
+    const linkCrash = resolveCrash !== null
+        ? null
+        : earlierLinkCrash(order, cjsNamedImportLinkCheck(program, entry, order, diags), esmNamedImportLinkCheck(program, entry, order, diags));
     return { diags, moduleOrder: order, startupCrash: resolveCrash ?? linkCrash };
 }
 /** Walks the entry's ESM instantiate graph exactly as V8 does — children
@@ -2278,21 +2453,18 @@ function preflight7(load) {
  * not modeled: those get a pointed fence instead. */
 function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
     const lexMemo = new Map();
-    const isRelative = isRelativeSpecifier;
-    // Relative specifiers resolve as ever; PROJECT imports (#alias/self-name
-    // — the same package.json-mediated edges preflight admits) join them so
+    // Project specifiers resolve as ever; aliases and package.json-mediated
+    // edges (#alias/self-name) join relative imports so
     // a named import THROUGH one of a CommonJS module keeps Node's lexer
     // check. Builtin/npm targets contribute nothing here — except opted-in
     // --npm-static packages, whose CJS entries face Node's lexer exactly
     // like program CJS files (their JS IS the program now).
     const resolveEdge = (from, spec) => {
-        if (isRelative(spec))
-            return resolveImport7(program, from, spec);
+        const project = resolveImport7(program, from, spec);
+        if (project !== null)
+            return project;
         const npmStatic = npmStaticDepSf7(program, from, spec);
-        if (npmStatic !== null)
-            return npmStatic;
-        const p = resolveProjectImport(from.fileName, spec);
-        return p !== null ? (program.getSourceFile(p) ?? null) : null;
+        return npmStatic;
     };
     // Reexport targets union in only when they resolve to CommonJS program
     // files (Node's cjsPreparseModuleExports rule).
@@ -2447,6 +2619,279 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
         loc,
     };
 }
+/** Node's strip-only loader exposes an empty `default` export for a default
+ * interface only when the `.ts` file is in an ambiguous (typeless) package
+ * scope. Explicitly ESM files (`.mts` and `.mjs`) and `.ts` files in a
+ * `"type": "module"` package do not get that placeholder. */
+function hasNodeTsDefaultInterfacePlaceholder7(sf) {
+    return sf.fileName.endsWith(".ts") && nearestPackageType(sf.fileName) === null;
+}
+/** Finds the first native-ESM link failure in the static module graph rooted
+ * at `entry`. This is used both for startup linking of the entry graph and
+ * for dynamic imports: a dynamically loaded graph rejects its import promise
+ * at this same link point instead of running any module body. */
+function analyzeEsmNamedImportLinks(program, entry) {
+    const checker = program.getTypeChecker();
+    const resolveEdge = (from, spec) => {
+        const project = resolveImport7(program, from, spec);
+        if (project !== null)
+            return project;
+        return npmStaticDepSf7(program, from, spec);
+    };
+    const runtimeExport = (dep, name, seenModules = new Set()) => {
+        if (seenModules.has(dep))
+            return undefined;
+        const nextSeen = new Set(seenModules);
+        nextSeen.add(dep);
+        const module = checker.getSymbolAtLocation(dep);
+        const exported = module?.getExports().get(name);
+        if (exported !== undefined) {
+            let resolved = exported;
+            const seenSymbols = new Set();
+            while ((resolved.flags & ts.SymbolFlags.Alias) !== 0 && !seenSymbols.has(resolved)) {
+                seenSymbols.add(resolved);
+                resolved = checker.getAliasedSymbol(resolved);
+            }
+            if (resolved.flags & ts.SymbolFlags.Value)
+                return resolved;
+            // Node's strip-only TypeScript loader materializes a direct `export
+            // default interface X {}` as an empty default export in an ambiguous
+            // `.ts` file. The checker correctly classifies the declaration as
+            // type-only, but the native ESM linker sees the runtime placeholder.
+            if (name === "default" &&
+                hasNodeTsDefaultInterfacePlaceholder7(dep) &&
+                checker.declarationsOf(resolved).some((declaration) => ts.isInterfaceDeclaration(declaration) &&
+                    ts.getModifiers(declaration)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) === true &&
+                    ts.getModifiers(declaration)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) === true)) {
+                return resolved;
+            }
+            return undefined;
+        }
+        // TypeScript 7's client-side module symbol exposes the module's own
+        // export table but not names contributed by `export *`. Follow those
+        // source edges explicitly, applying the ESM ambiguity rule: the same
+        // resolved symbol may arrive through multiple stars, while distinct
+        // symbols make the name unavailable. `default` never star-reexports.
+        if (name === "default")
+            return undefined;
+        let starExport;
+        for (const stmt of dep.statements) {
+            if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly || stmt.exportClause !== undefined)
+                continue;
+            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))
+                continue;
+            const candidate = runtimeExport(target, name, nextSeen);
+            if (candidate === undefined)
+                continue;
+            if (starExport !== undefined && starExport !== candidate)
+                return undefined;
+            starExport = candidate;
+        }
+        return starExport;
+    };
+    const firstMissingOf = (sf) => {
+        const imports = [];
+        for (const stmt of sf.statements) {
+            if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
+                continue;
+            const clause = stmt.importClause;
+            if (clause === undefined || clause.phaseModifier === ts.SyntaxKind.TypeKeyword)
+                continue;
+            const spec = stmt.moduleSpecifier.text;
+            const dep = resolveEdge(sf, spec);
+            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep))
+                continue;
+            if (clause.name !== undefined) {
+                imports.push({ local: clause.name.text, exportName: "default", spec, nameNode: clause.name, dep });
+            }
+            if (clause.namedBindings === undefined || !ts.isNamedImports(clause.namedBindings))
+                continue;
+            for (const element of clause.namedBindings.elements) {
+                if (element.isTypeOnly)
+                    continue;
+                const nameNode = element.propertyName ?? element.name;
+                imports.push({
+                    local: element.name.text,
+                    exportName: nameNode.text,
+                    spec,
+                    nameNode,
+                    dep,
+                });
+            }
+        }
+        // Node checks regular named requests in local-binding order. Keeping the
+        // same order as the CommonJS linker matters when one statement asks for
+        // more than one erased TypeScript export.
+        imports.sort((a, b) => (a.local < b.local ? -1 : a.local > b.local ? 1 : 0));
+        for (const request of imports) {
+            if (runtimeExport(request.dep, request.exportName) === undefined) {
+                return {
+                    exportName: request.exportName,
+                    spec: request.spec,
+                    nameNode: request.nameNode,
+                    sf,
+                };
+            }
+        }
+        for (const stmt of sf.statements) {
+            if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly)
+                continue;
+            const moduleSpecifier = stmt.moduleSpecifier;
+            const exportClause = stmt.exportClause;
+            if (moduleSpecifier === undefined || exportClause === undefined)
+                continue;
+            if (!ts.isStringLiteral(moduleSpecifier) || !ts.isNamedExports(exportClause))
+                continue;
+            const spec = moduleSpecifier.text;
+            const dep = resolveEdge(sf, spec);
+            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep))
+                continue;
+            for (const element of exportClause.elements) {
+                if (element.isTypeOnly)
+                    continue;
+                const nameNode = element.propertyName ?? element.name;
+                if (runtimeExport(dep, nameNode.text) === undefined) {
+                    return { exportName: nameNode.text, spec, nameNode, sf };
+                }
+            }
+        }
+        return null;
+    };
+    // The ESM instantiate graph is the same depth-first graph used by the CJS
+    // linker: dependencies are linked before the importing module, and a
+    // CommonJS/JSON target is a leaf for this native-export check.
+    const visited = new Set();
+    const dfs = (sf) => {
+        if (visited.has(sf))
+            return null;
+        visited.add(sf);
+        for (const stmt of sf.statements) {
+            if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
+                continue;
+            if (ts.isImportDeclaration(stmt) && stmt.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword)
+                continue;
+            const moduleSpecifier = stmt.moduleSpecifier;
+            if (moduleSpecifier === undefined || !ts.isStringLiteral(moduleSpecifier))
+                continue;
+            const dep = resolveEdge(sf, moduleSpecifier.text);
+            if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep))
+                continue;
+            const bad = dfs(dep);
+            if (bad !== null)
+                return bad;
+        }
+        return firstMissingOf(sf);
+    };
+    // 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;
+    if (bad !== null) {
+        return {
+            crash: {
+                message: `The requested module '${bad.spec}' does not provide an export named '${bad.exportName}'`,
+                className: "%SyntaxError",
+                loc: locOf7(bad.nameNode),
+            },
+            visited,
+            firstMissingOf,
+        };
+    }
+    return { crash: null, visited, firstMissingOf };
+}
+export function esmNamedImportLinkCrash(program, entry) {
+    return analyzeEsmNamedImportLinks(program, entry).crash;
+}
+function esmNamedImportLinkCheck(program, entry, moduleOrder, diags) {
+    const analysis = analyzeEsmNamedImportLinks(program, entry);
+    if (analysis.crash !== null)
+        return analysis.crash;
+    // A CommonJS entry can synchronously require an ESM graph. Node links that
+    // graph at the require site, after the CommonJS module has already begun
+    // evaluating, so this cannot use startupCrash (which would move the error
+    // 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))
+            continue;
+        const childFailure = analysis.firstMissingOf(sf);
+        if (childFailure !== null) {
+            diags.push(unsupportedDiag("SC1013", locOf7(childFailure.nameNode), "a named import of an unavailable export in an ES module reached through require() (Node throws its SyntaxError mid-evaluation at that require; make the import match the module's runtime exports)"));
+        }
+    }
+    return null;
+}
+/** Both named-export link checks run independently because their export
+ * questions are different (Node's CJS lexer versus TypeScript's value
+ * symbols). Their first failures still share one Node instantiate order: the
+ * module postorder established by preflight, then regular named imports by
+ * local binding name, then source-order re-exports. Pick the earlier result
+ * so a native ESM failure in a child cannot be hidden by a CJS failure in a
+ * later parent. */
+function earlierLinkCrash(moduleOrder, first, second) {
+    if (first === null)
+        return second;
+    if (second === null)
+        return first;
+    const moduleIndex = new Map(moduleOrder.map((sf, index) => [sf.fileName, index]));
+    const firstIndex = moduleIndex.get(first.loc.file) ?? Number.MAX_SAFE_INTEGER;
+    const secondIndex = moduleIndex.get(second.loc.file) ?? Number.MAX_SAFE_INTEGER;
+    if (firstIndex !== secondIndex)
+        return firstIndex < secondIndex ? first : second;
+    if (first.loc.start !== second.loc.start) {
+        const sf = moduleOrder[firstIndex];
+        if (sf === undefined)
+            return first.loc.start < second.loc.start ? first : second;
+        const rank = (crash) => {
+            const entries = [];
+            for (const stmt of sf.statements) {
+                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) {
+                            if (!element.isTypeOnly) {
+                                entries.push({
+                                    local: element.name.text,
+                                    start: (element.propertyName ?? element.name).getStart(sf),
+                                    kind: 0,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            entries.sort((a, b) => (a.local < b.local ? -1 : a.local > b.local ? 1 : 0));
+            const direct = entries.findIndex((entry) => entry.start === crash.loc.start);
+            if (direct >= 0)
+                return [0, direct];
+            let reexport = 0;
+            for (const stmt of sf.statements) {
+                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) {
+                    if (!element.isTypeOnly && (element.propertyName ?? element.name).getStart(sf) === crash.loc.start) {
+                        return [1, reexport];
+                    }
+                    if (!element.isTypeOnly)
+                        reexport++;
+                }
+            }
+            return [2, crash.loc.start];
+        };
+        const firstRank = rank(first);
+        const secondRank = rank(second);
+        if (firstRank[0] !== secondRank[0])
+            return firstRank[0] < secondRank[0] ? first : second;
+        return firstRank[1] <= secondRank[1] ? first : second;
+    }
+    return first;
+}
 /* node's builtin-module name list, for the SC1010 wording decision ("the
  * 'fs' module" vs the generic package message) — shared verbatim with the
  * retired 5.9.3 lane's builtinModules use. */
@@ -2521,16 +2966,11 @@ export function orderedImportsOf(program, sf) {
         if (!stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier))
             continue;
         const spec = stmt.moduleSpecifier.text;
-        const isRelative = isRelativeSpecifier(spec);
-        // Relative edges as ever; PROJECT imports (#alias/self-name — the
-        // package.json-mediated specifiers preflight admits as user-module
-        // edges) resolve to the same dep so the importer's %init header calls
-        // theirs. Builtin and npm bare specifiers stay null (resolveProjectImport
-        // answers only inside the project) — EXCEPT opted-in --npm-static
+        // Every project edge (relative, tsconfig alias, #alias, or self-name)
+        // resolves to the same dep so the importer's %init header calls theirs.
+        // Builtin and npm bare specifiers stay null — EXCEPT opted-in --npm-static
         // packages, whose entries are program modules the header must init.
-        const dep = isRelative
-            ? resolveImport7(program, sf, spec)
-            : (npmStaticDepSf7(program, sf, spec) ?? resolveProjectImportSf7(program, sf, spec));
+        const dep = resolveImport7(program, sf, spec) ?? npmStaticDepSf7(program, sf, spec);
         const isJson = dep !== null && dep.fileName.endsWith(".json");
         out.push({ stmt, dep: isJson ? null : dep });
     }
@@ -2553,19 +2993,6 @@ export function npmStaticDepSf7(program, sf, spec) {
         return null;
     return program.getSourceFile(npm.typesFile) ?? null;
 }
-/** resolveProjectImport lifted to SourceFile answers: the program's file
- * for a `#alias`/self-name resolution, or null (unresolved, or resolved
- * outside the program — declaration files included; callers that admit
- * d.ts answers probe resolveProjectImport directly). */
-function resolveProjectImportSf7(program, sf, spec) {
-    if (spec.startsWith("node:"))
-        return null;
-    const p = resolveProjectImport(sf.fileName, spec);
-    if (p === null)
-        return null;
-    const dep = program.getSourceFile(p) ?? null;
-    return dep !== null && !dep.isDeclarationFile ? dep : null;
-}
 /** True when `expr` is the `module.exports` property access. */
 export function isModuleExportsAccess(expr) {
     return (ts.isPropertyAccessExpression(expr) &&