@scriptc/compiler 0.4.6 → 0.4.8

package/dist/frontend/program.js

@@ -42,6 +42,7 @@ import { isFrontendIsland } from "../node-islands/boundary.js";
 import { builtinModules } from "node:module";
 import { dirname, isAbsolute, resolve } from "node:path";
 import * as ts from "./ts7/adapter.js";
+import { isSourcePhaseImport } from "./ts7/ast-node.js";
 import { commonJsModuleSyntaxDiag, invalidPackageConfigDiag, strictNullChecksFloorDiag, tscPassthroughDiag, unsupportedDiag, } from "../diagnostics/diagnostic.js";
 import { isNodeModulesPath, nearestInvalidPackageJsonPath, nearestPackageType, nearestPkgJsonPath, packageImportTarget, projectDtsRuntimeSibling, resolveBareModule, resolveProjectModule, resolveTypeDirective, setProjectPathMappings, setProjectRealm, } from "./resolve.js";
 import { probeNodeImportRefusal, probeNodeRequireRefusal } from "./npm.js";
@@ -56,8 +57,9 @@ import { cjsLexedExportsOfFile, cjsVisibleNames } from "./cjs-syntax.js";
 import { ambientDtsPath, fallbackDtsPath, fallbackModulesNamedIn, isFallbackDtsPath, isNodeTypesPath, overridesDtsPath, tsgoPath, } from "./dts-paths.js";
 import { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_NODE_MODULES, unsupportedModuleFeatureOf, TEMPORAL_GLOBAL, } from "./builtin-modules.js";
 import { clearWorkspacePackages, isRelativeSpecifier, isWorkspacePackageName, npmPackageNameOf, packageNameOfSpecifier, registerWorkspacePackage, workspacePackageOfPath, } from "./workspace-registry.js";
-import { ADOPTED_OPTIONS, isJsSourceFileName, JS_ANY_OPERATOR_CODES, JS_RELAXED_TSC_CODES, } from "./tsc-codes.js";
+import { ADOPTED_OPTIONS, isJsSourceFileName, jsOpinion, jsTscCodeTriage, } from "./tsc-codes.js";
 import { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
+import { earlyErrorDiagnostics7 } from "./early-errors.js";
 import { forkTargetPaths } from "./fork-target.js";
 import { workerTargetPaths } from "./worker-target.js";
 import { erasedTypeOnlyImport, typeOnlyNamedImport, typeOnlyReachedFiles, } from "./type-only-imports.js";
@@ -66,6 +68,7 @@ import { planDeclProjection, resetDeclBoundaryOrigins, } from "./decl-projection
 import { configureTypePatches, packageSourceText } from "./type-patches/layer.js";
 import { resetDeclOriginVersions } from "./lowering/decl-origin.js";
 import { reportShapes, resetShapeOverlay, shapeOverlayDone, shapeOverlayEnabled, shapeOverlayer, captureShapeOverlayState, } from "./shape-inference/index.js";
+import { jsInferenceEnabled } from "./js-inference.js";
 import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
 import { containsJsx, firstJsx, jsxEmitName, jsxEmitPlan, jsxPragmas, lowerJsx, } from "./jsx-source.js";
 const BASE_OPTIONS = {
@@ -704,7 +707,8 @@ overlayer) {
             if (extraRoots.length === 0)
                 break;
             program.dispose();
-            programRoots.push(...extraRoots);
+            for (const root of extraRoots)
+                programRoots.push(root);
             program = host.createProgram([...programRoots, overridesDtsPath()], options);
             if (pass === 31)
                 throw new Error("static program-root discovery did not converge");
@@ -1095,7 +1099,10 @@ export function loadProgram(entryPath, services, opts) {
         // of the same build, which preflight can create after the overlay
         // rounds, so it leaves the registry as this load set it.
         resetShapeOverlay();
-        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0, projector, npmStaticPackages.length > 0 && shapeOverlayEnabled() ? shapeOverlayer : undefined);
+        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0, projector, (npmStaticPackages.length > 0 && shapeOverlayEnabled()) ||
+            (jsInferenceEnabled() && process.env["SCRIPTC_SHAPE_OVERLAY"] !== "0")
+            ? shapeOverlayer
+            : undefined);
         // Shape inference, stage S1: a report only (SCRIPTC_DEBUG_SHAPES).
         const shapes = process.env["SCRIPTC_DEBUG_SHAPES"];
         if (shapes !== undefined && shapes !== "" && shapes !== "0" && npmStaticPackages.length > 0)
@@ -1166,63 +1173,103 @@ function declBoundaryDroppedDiag(file) {
  * 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, inlineRequireCycleCalls, moduleEdges, dynamicImportRejections, } = preflight7(load);
+    const { diags, moduleOrder, startupCrash, inlineRequireCycleCalls, moduleEdges, dynamicImportRejections, admittedOpinions, } = preflight7(load);
     load.moduleOrder = moduleOrder;
     load.startupCrash = startupCrash;
     load.inlineRequireCycleCalls = inlineRequireCycleCalls;
     load.moduleEdges = moduleEdges;
     load.dynamicImportRejections = dynamicImportRejections;
+    load.admittedOpinions = admittedOpinions;
+    // Measurement aid: prints every opinion site this preflight admitted, so a
+    // corpus run can show which rows carry evidence (SCRIPTC_DEBUG_ADMITTED=1).
+    // Silent by default; no lowering reads the set.
+    if (process.env["SCRIPTC_DEBUG_ADMITTED"] === "1")
+        for (const site of admittedOpinions)
+            process.stderr.write(`scriptc admitted TS${site.code} ${site.view} ${site.file}:${site.pos}-${site.end}\n`);
     return diags;
 }
-/* Finding 5: tsgo's strict CommonJS modeling fires checker codes on JS
- * shapes 5.9.3 accepted, and the real hazards those shapes carry are fenced
- * by scriptc's OWN analysis, never by these codes — so for JS FILES ONLY
- * they join the relaxation (TS sources keep the full gate; the order-parity
- * harness holds both lanes to identical verdicts, so a case where 5.9.3
- * itself raises one of these on a JS file would fail there, not slip by):
- *  - TS2309 ("export assignment with other exported elements") on the
- *    table-then-member pattern — cjsExportDiscardReason names every export
- *    Node actually discards.
- *  - TS2323 ("cannot redeclare exported variable") on symbol-keyed expando
- *    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). */
-// 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]);
-/** Relaxed JavaScript codes that checked JavaScript files keep: values of
- * another type in a typed slot (2322 and its elaborations 2740/2741/2559,
- * 2345, 2769), call arity (2554-2556) and incompatible subclass members
- * (2415). */
-const CHECKED_JS_ENFORCED_CODES = new Set([
-    2322, 2345, 2415, 2554, 2555, 2556, 2559, 2740, 2741, 2769,
-]);
-function suppressedJsStrictness7(d) {
-    const file = d.fileName;
-    if (!file || !isJsSourceFileName(file))
-        return false;
-    if (JS_RELAXED_TSC_CODES.has(d.code) || TS7_JS_RELAXED_EXTRA.has(d.code))
-        return true;
-    // The 8xxx range is TypeScript's JSDoc-specific diagnostic family
-    // (malformed tags, signature/tag mismatches): comment semantics with no
-    // runtime meaning in a JS file.
-    if (d.code >= 8000 && d.code <= 8999)
-        return true;
-    if (JS_ANY_OPERATOR_CODES.has(d.code)) {
-        return ts.flattenDiagnosticMessageText(d, "\n").includes("'any'");
-    }
-    // The deprecated Buffer(...) call without `new`, which Node's Buffer
-    // function accepts (containers/bytes.ts lowers it), and fs.ReadStream(...)
-    // and fs.WriteStream(...), which construct their stream
-    // (builtins/fs-streams.ts).
-    if (d.code === 2348) {
-        const text = ts.flattenDiagnosticMessageText(d, "\n");
-        return (text.includes("'BufferConstructor'") ||
-            text.includes("'typeof ReadStream'") ||
-            text.includes("'typeof WriteStream'"));
+/** The module evaluation order and the graph facts derived with it, without
+ * the diagnostics. `--npm-static`'s library fixpoint reloads the program
+ * once per package it discovers and reads the order alone (to find the next
+ * package); only the last program's diagnostics are ever reported, and its
+ * checkPreflight completes this walk instead of repeating it. */
+export function checkModuleOrder(load) {
+    registerWorkspaceEdges(load);
+    fillPreflightFields(load, preflightStructure(load));
+}
+function fillPreflightFields(load, structure) {
+    load.moduleOrder = structure.order;
+    load.inlineRequireCycleCalls = structure.inlineRequireCycleCalls;
+    load.moduleEdges = structure.moduleEdges;
+    load.dynamicImportRejections = structure.dynamicImportRejections;
+}
+/** The innermost node whose token span contains [pos, end): the node an
+ * opinion row's site guard inspects, and the one `island` rows ask about
+ * (a diagnostic carries no node). */
+function diagnosticNode7(sf, pos, end) {
+    let node = sf;
+    // The lowering's nesting fence is 200 levels; a recovered AST is never
+    // deeper than that on the path to one diagnostic.
+    for (let depth = 0; depth < 200; depth++) {
+        let next;
+        ts.forEachChild(node, (child) => {
+            if (ts.tokenStartOfNode(child) <= pos && end <= child.end) {
+                next = child;
+                return true;
+            }
+            return undefined;
+        });
+        if (next === undefined)
+            break;
+        node = next;
     }
-    return false;
+    return node;
+}
+/** The JS_OPINIONS admission for one checker diagnostic (tsc-codes.ts), or
+ * null when the diagnostic stays. Five conditions, in order:
+ *
+ *  1. the file is a JavaScript source (never .ts/.mts/.cts/.tsx/.d.ts);
+ *  2. a row admits the code, and the file is unchecked JavaScript unless the
+ *     row is one a checked project has always seen (`checkedJs: "enforce"`);
+ *  3. the diagnostic is a checker diagnostic, not a parser one (a syntactic
+ *     diagnostic leaves a recovered AST);
+ *  4. the row's site guard accepts the diagnostic's node, if it has one;
+ *  5. an `island` row does not apply in strict code (scriptc's own
+ *     isStrictCode, never tsc's module opinion).
+ *
+ * Admission says nothing about the LOWERING: the caller records the site
+ * (AdmittedOpinion) so a view's lowering path can be gated on it. */
+function jsOpinionOf7(p, d, projectCheckJs, syntacticOf) {
+    if (d.fileName === undefined || !isJsSourceFileName(d.fileName))
+        return null;
+    const opinion = jsOpinion(d.code);
+    if (opinion === null)
+        return null;
+    const sf = p.getSourceFile(d.fileName);
+    if (sf !== undefined &&
+        opinion.checkedJs === "enforce" &&
+        isCheckedJsSourceFile(sf, projectCheckJs))
+        return null;
+    const pos = d.pos;
+    const end = d.end;
+    const spanless = pos === undefined || end === undefined;
+    // A diagnostic with no span, or one that names a file the program does
+    // not carry, cannot be placed in the AST. A row with no node guard needs
+    // no node, so the admission applies exactly as it always has; the caller
+    // records nothing (there is no site a view could be gated on).
+    const nodeFree = opinion.site === undefined && opinion.view !== "island";
+    if (spanless || sf === undefined)
+        return nodeFree ? opinion : null;
+    if (syntacticOf(sf).some((s) => s.code === d.code && s.pos === pos && s.end === end))
+        return null;
+    if (nodeFree)
+        return opinion;
+    const node = diagnosticNode7(sf, pos, end);
+    if (opinion.site !== undefined && !opinion.site(node, d))
+        return null;
+    if (opinion.view === "island" && isStrictCode(node))
+        return null;
+    return opinion;
 }
 /** The specifier of a `require("...")` call: the callee is the bare
  * identifier `require` and the single argument a string literal. The one
@@ -2398,6 +2445,96 @@ function isAssignmentTarget7(node) {
         parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
         parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment);
 }
+/** True when the identifier is a reference position that WRITES: an
+ * assignment (or compound-assignment) target, a `++`/`--` operand, a
+ * for-in/for-of head, or an element of a destructuring pattern — through
+ * parentheses and pattern containers, exactly the shapes a sloppy-mode
+ * implicit global can be introduced by. */
+export function isJsWriteTarget7(node) {
+    let cur = node;
+    for (;;) {
+        const parent = cur.parent;
+        if (parent === undefined)
+            return false;
+        if (ts.isParenthesizedExpression(parent)) {
+            cur = parent;
+            continue;
+        }
+        if (ts.isBinaryExpression(parent))
+            return (parent.left === cur &&
+                parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment);
+        if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent))
+            return (parent.operand === cur &&
+                (parent.operator === ts.SyntaxKind.PlusPlusToken ||
+                    parent.operator === ts.SyntaxKind.MinusMinusToken));
+        if (ts.isForInStatement(parent) || ts.isForOfStatement(parent))
+            return parent.initializer === cur;
+        if (ts.isArrayLiteralExpression(parent) || ts.isObjectLiteralExpression(parent)) {
+            cur = parent;
+            continue;
+        }
+        if ((ts.isShorthandPropertyAssignment(parent) && parent.name === cur) ||
+            (ts.isPropertyAssignment(parent) && parent.initializer === cur) ||
+            ((ts.isSpreadElement(parent) || ts.isSpreadAssignment(parent)) && parent.expression === cur)) {
+            cur = parent;
+            continue;
+        }
+        return false;
+    }
+}
+/** Nothing binds `node`: the tsc had no symbol, and a shorthand pattern's
+ * name has no VALUE binding either (its property symbol is the target, not a
+ * declaration of the name being written). */
+function undeclaredJsName7(checker, node) {
+    const parent = node.parent;
+    if (parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === node)
+        return checker.getShorthandAssignmentValueSymbol(parent) === undefined;
+    return checker.getSymbolAtLocation(node) === undefined;
+}
+/** A `.js` WRITE to a name nothing declares (plan D-2/D-5). Sloppy mode
+ * resolves such a write by creating a property on Node's global object —
+ * process-wide state a native binary has no object for — so the program is
+ * refused at build time, under SC1091, whose text names the Node-island
+ * route those semantics need. A READ of the same name is admitted instead:
+ * it throws Node's own catchable `ReferenceError` at the access
+ * (lowering/expressions/identifiers.ts). TypeScript input never reaches
+ * either path — an undeclared name is a compile error there. */
+function jsUndeclaredWriteDiags(program, files) {
+    const diags = [];
+    const checker = program.getTypeChecker();
+    for (const sf of files) {
+        if (!isJsSourceFileName(sf.fileName))
+            continue;
+        const stack = [sf];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            // An empty name is a parse-recovery artifact (`@import x = require(…)`
+            // in a JSDoc prologue leaves one behind), never a reference a program
+            // writes; the syntax error that created it is already reported.
+            if (ts.isIdentifier(node) &&
+                node.text !== "" &&
+                isJsWriteTarget7(node) &&
+                undeclaredJsName7(checker, node)) {
+                const sloppyWrite = !isStrictCode(node);
+                const diag = unsupportedDiag("SC1091", { file: sf.fileName, start: node.getStart(sf), end: node.end }, `writing the undeclared name '${node.text}' in a JavaScript source`);
+                // A sloppy-mode write creates the global at run time, a sloppy-only
+                // semantic the native tier does not implement: the reason lets an
+                // automatic island policy put this module in a Node island instead
+                // of refusing the build. A strict-mode write throws ReferenceError,
+                // which is an ordinary lowering gap and stays a plain refusal.
+                if (sloppyWrite)
+                    diag.reason = "implicit-global-write";
+                diags.push(diag);
+            }
+            ts.forEachChild(node, (child) => {
+                stack.push(child);
+                return undefined;
+            });
+        }
+    }
+    return diags;
+}
 /** True when `node` is inside the try block of a try statement in the same
  * function (a catch clause or finally block does not count). A class field
  * initializer runs when the class is instantiated, so it is a boundary too. */
@@ -2690,6 +2827,36 @@ function isCjsJsFile7(sf, program) {
 export function isCjsJsFile(sf, program) {
     return isCjsJsFile7(sf, program);
 }
+function hasUseStrictDirective(statements) {
+    for (const statement of statements) {
+        if (!ts.isExpressionStatement(statement) || !ts.isStringLiteral(statement.expression))
+            return false;
+        if (statement.expression.text === "use strict")
+            return true;
+    }
+    return false;
+}
+/** Whether `node` runs in strict mode code: inside a class body, a function
+ * with a "use strict" directive, a module, or a script that starts with
+ * "use strict". CommonJS JavaScript is sloppy otherwise; the sloppy-only
+ * semantics (implicit globals, `with`, direct eval, Annex B) need a Node
+ * island. */
+export function isStrictCode(node) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (ts.isClassDeclaration(parent) || ts.isClassExpression(parent))
+            return true;
+        if (ts.isFunctionLike(parent) &&
+            parent.body &&
+            ts.isBlock(parent.body) &&
+            hasUseStrictDirective(parent.body.statements.nodes))
+            return true;
+        if (ts.isSourceFile(parent)) {
+            return (hasUseStrictDirective(parent.statements.nodes) ||
+                (!isCjsJsFile7(parent) && (isNodeEsmFile7(parent) || ts.isExternalModule(parent))));
+        }
+    }
+    return false;
+}
 /** The self-import TDZ fences: for `import { x } from "<self>"` (default
  * and namespace forms included), any TOP-LEVEL reference lexically above
  * the aliased declaration observes Node's temporal dead zone — the direct
@@ -4107,7 +4274,8 @@ function cycleReachedDeferredReferences7(program, evaluation, candidates) {
             continue;
         const units = unitsOfName.get(name);
         unitsBySymbol.set(symbol, [...(unitsBySymbol.get(symbol) ?? []), ...units]);
-        allUnits.push(...units);
+        for (const unit of units)
+            allUnits.push(unit);
     }
     // A named class expression's inner name (`class Impl { static x =
     // Impl.m(); }`) names the class inside its own body, as the binding it
@@ -4295,7 +4463,8 @@ export function moduleEarlyBindings(program, order) {
     for (const sf of order) {
         if (sf.isDeclarationFile || exact.has(sf))
             continue;
-        out.push(...moduleEarlyBindingsOf7(program, sf, order));
+        for (const binding of moduleEarlyBindingsOf7(program, sf, order))
+            out.push(binding);
     }
     program.analysis.moduleEarlyBindings = { key, bindings: out };
     return out;
@@ -4795,13 +4964,18 @@ function typeOnlyNamespace7(decl) {
  * 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, resolutionKind = "import") {
+function resolveImport7(program, from, specifier, resolutionKind = "import", 
+/** False for the graph passes that over-approximate edges (see
+ * `resolveRuntimeEdge`): they resolve specifiers Node may never load, so
+ * a miss there is no evidence about the package's entry and must not
+ * classify it. The walks that model real loads pass the default. */
+reportMiss = true) {
     const resolved = resolveProjectModule(from.fileName, specifier);
     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)
+        ? npmStaticProgramDep(program, npm.packageName, npm.typesFile, reportMiss)
         : null;
 }
 function resolveNpmImport7(fromFileName, specifier, resolutionKind = "import") {
@@ -4871,14 +5045,16 @@ function npmStaticProgramFile(program, resolvedFile) {
  * entry maps to, or null with the package marked an offender (resolution
  * still answering declarations, or the file missing from the type-checked
  * program — a path-identity mismatch between the two resolvers). */
-function npmStaticProgramDep(program, packageName, resolvedFile) {
+function npmStaticProgramDep(program, packageName, resolvedFile, reportMiss = true) {
     if (!isJsSourceFileName(resolvedFile)) {
-        reportNpmStaticOffender(packageName, `its import resolves to '${resolvedFile}', not to runtime JavaScript`);
+        if (reportMiss)
+            reportNpmStaticOffender(packageName, `its import resolves to '${resolvedFile}', not to runtime JavaScript`);
         return null;
     }
     const dep = npmStaticProgramFile(program, resolvedFile);
     if (dep === null) {
-        reportNpmStaticOffender(packageName, `its entry '${resolvedFile}' did not join the type-checked program`);
+        if (reportMiss)
+            reportNpmStaticOffender(packageName, `its entry '${resolvedFile}' did not join the type-checked program`);
         return null;
     }
     return dep;
@@ -4917,27 +5093,58 @@ export function checkPreflightTs7(entryPath, host) {
         load.disposeAll();
     }
 }
-function preflight7(load) {
-    const { program, entry } = load;
-    const diags = [...load.configDiags];
-    // An explicit entry can itself live in an installed package. Its own
-    // source files are program code, including relative barrels and sibling
-    // modules; their location must not erase the module graph.
-    // Match the full installed directory, not just the package name, and
-    // exclude nested installations so dependencies keep their npm policy.
-    const entryPackageFile = entryPackageFilePredicate(entry.fileName);
-    // Workspace-linked packages register BEFORE the tsc gate. Their files
-    // live at realpaths OUTSIDE node_modules (the monorepo-tool symlink
-    // shape), so nothing path-shaped marks them as npm surface — yet their
-    // shipped JS follows the same foreign-tsconfig rules as node_modules JS.
-    // The lazy
-    // registration inside the import-fence walk below runs AFTER errorsOf,
-    // too late for the gate, so one pass over the program's import edges
-    // registers them up front: every bare specifier any program file loads —
-    // import/export declarations, dynamic import("literal") (tsgo chases
-    // those into the program too; a CLI reaches its workspace sibling exactly
-    // that way), require("literal") — resolved with the own resolver,
-    // workspace answers recorded.
+/** Whether a declaration file has the runtime file TypeScript pairs it
+ * with (`x.d.ts` with `x.js`, `x.d.mts` with `x.mjs`, `x.d.cts` with
+ * `x.cjs`): a specifier that resolves to the declaration then still names a
+ * module Node can load. */
+function declarationHasRuntimeFile(declaration) {
+    const name = declaration.fileName;
+    const pairs = [
+        [".d.ts", ".js"],
+        [".d.mts", ".mjs"],
+        [".d.cts", ".cjs"],
+    ];
+    for (const [declared, runtime] of pairs)
+        if (name.endsWith(declared))
+            return trackedFileExists(name.slice(0, -declared.length) + runtime);
+    return false;
+}
+/** Whether two resolutions name the same module file. Their spellings differ
+ * routinely — a tsconfig `paths` answer keeps the project's spelling where
+ * the npm resolver answers realpath'd — so the real paths decide. */
+function sameResolvedFile(a, b) {
+    const normalize = (path) => path.replaceAll("\\", "/");
+    if (normalize(a) === normalize(b))
+        return true;
+    return normalize(trackedRealpath(a) ?? a) === normalize(trackedRealpath(b) ?? b);
+}
+/** A program file TypeScript's checker pulled in from a package the build
+ * does not compile — unselected node_modules JavaScript, or an unselected
+ * workspace package's shipped JavaScript at a realpath outside node_modules
+ * (the symlinked-install shape): Node never loads it as program source. */
+function unselectedPackageJsFilePredicate(entryFileName) {
+    const entryPackageFile = entryPackageFilePredicate(entryFileName);
+    return (file) => isJsSourceFileName(file) &&
+        !entryPackageFile(file) &&
+        npmStaticPackageOfPath(file) === null &&
+        (isNodeModulesPath(file) || workspacePackageOfPath(file) !== null);
+}
+/** Workspace-linked packages register before the tsc gate. Their files live
+ * at realpaths OUTSIDE node_modules (the monorepo-tool symlink shape), so
+ * nothing path-shaped marks them as npm surface — yet their shipped JS
+ * follows the same foreign-tsconfig rules as node_modules JS. The lazy
+ * registration inside the import-fence walk registers them too, but too late
+ * for the gate, so one pass over the program's import edges registers them up
+ * front: every bare specifier any program file loads — import/export
+ * declarations, dynamic import("literal") (tsgo chases those into the program
+ * too; a CLI reaches its workspace sibling exactly that way),
+ * require("literal") — resolved with the own resolver, workspace answers
+ * recorded. Runs once per load, ahead of the gate and the walk. */
+function registerWorkspaceEdges(load) {
+    if (load.workspaceProbed === true)
+        return;
+    load.workspaceProbed = true;
+    const { program } = load;
     {
         const supportedBuiltins = new Set(SUPPORTED_NODE_MODULES);
         const probed = new Set();
@@ -4963,317 +5170,126 @@ function preflight7(load) {
                 probe(sf.fileName, specifier);
         }
     }
-    const toPassthrough = (d) => {
-        const message = ts.flattenDiagnosticMessageText(d, "\n");
-        // File-less (global/options) diagnostics anchor at the entry with a
-        // zero span, exactly like the 5.9.3 lane's `d.start ?? 0` fallback.
-        const file = d.fileName ?? entry.fileName;
-        const start = d.fileName !== undefined ? d.pos : 0;
-        const end = d.fileName !== undefined ? d.end : 0;
-        const diag = tscPassthroughDiag(message, { file, start, end });
-        const hint = typeWorldHint(d, message, load);
-        if (hint !== null) {
-            diag.typeWorld = true;
-            diag.hint = hint;
+}
+function preflightStructure(load) {
+    if (load.preflightStructure === undefined)
+        load.preflightStructure = preflightStructure7(load);
+    return load.preflightStructure;
+}
+function preflightStructure7(load) {
+    const { program, entry } = load;
+    // The walk's own diagnostics. The config diagnostics and the tsc gate are
+    // preflightDiagnostics7's, which reports them ahead of these.
+    const diags = [];
+    const unselectedPackageJsFile = unselectedPackageJsFilePredicate(entry.fileName);
+    // An explicit entry can itself live in an installed package. Its own
+    // source files are program code, including relative barrels and sibling
+    // modules; their location must not erase the module graph.
+    // Match the full installed directory, not just the package name, and
+    // exclude nested installations so dependencies keep their npm policy.
+    const entryPackageFile = entryPackageFilePredicate(entry.fileName);
+    // Preflight and lowering share this CheckerFacade. Claim executable
+    // source files after workspace discovery and the tsc gate but before
+    // structural preflight checker queries, so a miss cannot trigger the old
+    // whole-file sweep (and eagerly fetch every dead body's answers). The
+    // structure wave includes declaration headers and top-level code;
+    // reachable bodies are added by lowering's worklists.
+    const ambient = ambientDtsPath();
+    const programFiles = program
+        .getImplementationSourceFiles()
+        .filter((sf) => sf.fileName !== ambient &&
+        !sf.isDeclarationFile &&
+        !sf.fileName.endsWith(".json") &&
+        (!isNodeModulesPath(sf.fileName) ||
+            entryPackageFile(sf.fileName) ||
+            npmStaticPackageOfPath(sf.fileName) !== null) &&
+        !unselectedPackageJsFile(sf.fileName));
+    // Files reached only through `import type` / `export type … from` are
+    // checker input, never program modules: Node does not load them, so
+    // their imports and syntax must not fence the program.
+    //
+    // Reachability over-approximates: `callReferencesOf` and the reexport
+    // planner count EVERY call with a leading string literal as a loading
+    // edge, so a bare specifier that merely names a package — a model id
+    // passed to a catalog helper, a settings key passed to `markModified` —
+    // reaches npm resolution here. Whether this walk runs at all depends on
+    // the program it is handed (it early-returns unless an erased reference
+    // resolves, and the island rounds change the program), so classifying a
+    // miss from it made package selection depend on program composition: the
+    // same build could refuse a static package's entry as "did not join the
+    // type-checked program" or compile it, run to run. Report nothing from
+    // these edges; the walks that model real loads (import/export
+    // declarations and `require()`/`import()` calls) own the offender
+    // classification.
+    const resolveRuntimeEdge = (sf, spec, resolutionKind) => resolveImport7(program, sf, spec, resolutionKind, false) ??
+        npmStaticDepSf7(program, sf, spec, resolutionKind);
+    const typeOnlyFiles = typeOnlyReachedFiles(program, entry, programFiles, () => [
+        ...forkTargetPaths(program, program.getImplementationSourceFiles()),
+        ...workerTargetPaths(program, program.getImplementationSourceFiles()),
+    ], resolveRuntimeEdge);
+    const runtimeFiles = typeOnlyFiles.size === 0 ? programFiles : programFiles.filter((sf) => !typeOnlyFiles.has(sf));
+    const userFiles = npmStaticActive()
+        ? planNpmStaticReexports(program, entry, runtimeFiles, [
+            ...createRequireProgramRoots7(program),
+            ...forkTargetPaths(program, program.getImplementationSourceFiles()),
+            ...workerTargetPaths(program, program.getImplementationSourceFiles()),
+        ], resolveRuntimeEdge)
+        : runtimeFiles;
+    program.getTypeChecker().prefetchSourceFileStructures(userFiles);
+    // Unselected node_modules JS is not native program source even when
+    // maxNodeModuleJsDepth pulled it into the checker (nodeModulesJsSuppressed).
+    // Node stops at the nearest package.json even when it is malformed, and
+    // an explicit CommonJS scope (or .cjs/.cts extension) disables ambiguous-
+    // file syntax detection entirely. TypeScript's bundler checker models
+    // neither loader rule, so restore them before any module-edge analysis:
+    // one malformed-scope diagnostic per package file, and one pointed syntax
+    // diagnostic per CommonJS source file.
+    const invalidPackageConfigs = new Set();
+    for (const sf of userFiles) {
+        const invalidConfig = nearestInvalidPackageJsonPath(sf.fileName);
+        if (invalidConfig !== null) {
+            if (!invalidPackageConfigs.has(invalidConfig)) {
+                invalidPackageConfigs.add(invalidConfig);
+                diags.push(invalidPackageConfigDiag(invalidConfig, { file: sf.fileName, start: 0, end: 0 }));
+            }
+            continue;
         }
-        return diag;
-    };
-    /* TS7 checker change (not finding 5, same discipline): tsgo types a
-     * NAMESPACE import as the spec's non-callable module namespace object
-     * even when the module is declared with the callable `export =` shape —
-     * 5.9.3 bound the callable value directly, so `import * as a from
-     * "node:assert"; a(x)` typechecked there and draws TS2349 here. Those
-     * callable module objects are scriptc's OWN declared surface, and calls
-     * through the namespace binding are fenced per site by the lowering (the
-     * assert-fences fixture pins the wording), so tsgo's extra TS2349 on
-     * exactly those callees — an identifier that is a namespace-import
-     * binding of a supported builtin module — is suppressed to the 5.9.3
-     * verdict. Nothing else rides this: any other non-callable call keeps
-     * tsc's voice in both lanes. */
-    const builtinNamespaceNames = new Map();
-    const namespaceCalleeSuppressed = (p, d) => {
-        if (d.code !== 2349 || d.fileName === undefined)
-            return false;
-        let names = builtinNamespaceNames.get(d.fileName);
-        if (!names) {
-            names = new Set();
-            builtinNamespaceNames.set(d.fileName, names);
-            const sf = p.getSourceFile(d.fileName);
-            for (const stmt of sf?.statements?.nodes ?? []) {
-                if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
-                    continue;
-                if (canonicalBuiltinModule(stmt.moduleSpecifier.text) === null)
-                    continue;
-                const bindings = stmt.importClause?.namedBindings;
-                if (bindings && ts.isNamespaceImport(bindings))
-                    names.add(bindings.name.text);
+        if (!isNodeEsmFile7(sf, program)) {
+            const marker = nodeEsmSyntaxMarker7(sf);
+            if (marker !== null)
+                diags.push(commonJsModuleSyntaxDiag(locOf7(marker)));
+        }
+    }
+    const ambientModules = new Set(SUPPORTED_NODE_MODULES);
+    // Ambient `declare module "name"` declarations anywhere in the program —
+    // exact names and `*` patterns — so the import fence can say "type
+    // surface only, no runtime module" instead of the generic package story.
+    // Computed lazily: the scan only runs when a bare-import fence is about
+    // to fire.
+    let ambientModuleDecls = null;
+    const ambientDeclared = (spec) => {
+        if (ambientModuleDecls === null) {
+            ambientModuleDecls = { names: new Set(), patterns: [] };
+            for (const f of program.getSourceFiles()) {
+                for (const s of f.statements.nodes) {
+                    if (!ts.isModuleDeclaration(s) || !ts.isStringLiteral(s.name))
+                        continue;
+                    const name = s.name.text;
+                    if (name.includes("*"))
+                        ambientModuleDecls.patterns.push(name);
+                    else
+                        ambientModuleDecls.names.add(name);
+                }
             }
         }
-        if (names.size === 0)
-            return false;
-        const sf = p.getSourceFile(d.fileName);
-        return sf !== undefined && names.has(sf.text.slice(d.pos, d.end));
-    };
-    const npmStaticFileSuppressed = (d) => d.fileName !== undefined && npmStaticPackageOfPath(d.fileName) !== null;
-    const unselectedPackageJsFile = (file) => isJsSourceFileName(file) &&
-        !entryPackageFile(file) &&
-        npmStaticPackageOfPath(file) === null &&
-        (isNodeModulesPath(file) || workspacePackageOfPath(file) !== null);
-    const nodeModulesJsSuppressed = (d) => d.fileName !== undefined && unselectedPackageJsFile(d.fileName);
-    /* JSDoc TYPE positions in JS files are documentation Node never reads:
-     * a name-resolution failure THERE (2304/2552 — the pattern's utilities.js
-     * spells a mapped type over a @template name it never declared) types
-     * as the error-any and the per-site fences apply, same stance as the
-     * strictness families above. A 2300 duplicate-identifier PAIR formed by
-     * a @typedef and a same-named class/function is the same story — the
-     * typedef half sits inside the comment, and the code half is suppressed
-     * exactly when its partner (same file, same name) was comment-side, so
-     * a REAL duplicate declaration (both halves in code — Node's own
-     * SyntaxError) keeps tsc's voice. */
-    const insideBlockComment = (text, pos) => {
-        const open = text.lastIndexOf("/*", pos);
-        if (open < 0)
-            return false;
-        const close = text.indexOf("*/", open + 2);
-        return close === -1 || close >= pos;
-    };
-    const jsdocTypeSuppressed = (p, d, commentDup) => {
-        if (d.fileName === undefined || !isJsSourceFileName(d.fileName))
-            return false;
-        if (d.code !== 2304 && d.code !== 2552 && d.code !== 2300 && d.code !== 1003)
-            return false;
-        if (d.pos === undefined)
-            return false;
-        const sf = p.getSourceFile(d.fileName);
-        if (!sf)
-            return false;
-        if (insideBlockComment(sf.text, d.pos))
+        if (ambientModuleDecls.names.has(spec))
             return true;
-        return d.code === 2300 && commentDup.has(`${d.fileName}:${sf.text.slice(d.pos, d.end)}`);
-    };
-    /* `typeof window` / `typeof self` in a JavaScript file: the operand of
-     * typeof may name a global nothing declares (Node answers "undefined"
-     * and never throws), the feature-detection idiom every isomorphic
-     * package uses, and the guarded uses of that name (`typeof window < "u"
-     * ? window : …`) are code Node never runs. A name the file feature-tests
-     * this way is therefore not a type error in JavaScript; a reached use
-     * still meets the lowering's located refusal. TypeScript files keep the
-     * error and its hint. */
-    const typeofTestedNameSuppressed = (p, d) => {
-        if (d.code !== 2304 && d.code !== 2552 && d.code !== 2584)
-            return false;
-        if (d.fileName === undefined || !isJsSourceFileName(d.fileName))
-            return false;
-        if (d.pos === undefined || d.end === undefined)
-            return false;
-        const sf = p.getSourceFile(d.fileName);
-        if (!sf)
-            return false;
-        const name = sf.text.slice(d.pos, d.end);
-        if (!/^[A-Za-z_$][\w$]*$/.test(name))
-            return false;
-        return new RegExp(`\\btypeof\\s*\\(?\\s*${name.replace(/\$/g, "\\$")}(?![\\w$])`).test(sf.text);
-    };
-    // A `return` at the top level of a CommonJS module (TS1108): Node runs
-    // the module as a function body, so the return ends the module's
-    // evaluation. ES modules and TypeScript keep the error.
-    const cjsTopLevelReturnSuppressed = (p, d) => {
-        if (d.code !== 1108 || d.fileName === undefined || !isJsSourceFileName(d.fileName))
-            return false;
-        const sf = p.getSourceFile(d.fileName);
-        return sf !== undefined && isCjsJsFile7(sf, p);
-    };
-    const workspaceImplicitAnySuppressed = (p, d) => {
-        if (d.code !== 7016 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
-            return false;
-        const sf = p.getSourceFile(d.fileName);
-        if (!sf)
-            return false;
-        const spec = sf.text.slice(d.pos, d.end).replace(/^['"]|['"]$/g, "");
-        const prefix = spec.startsWith("@")
-            ? spec.split("/").slice(0, 2).join("/")
-            : spec.split("/")[0];
-        return isWorkspacePackageName(prefix);
-    };
-    // A JavaScript file that TypeScript checks keeps the type errors that
-    // protect its JSDoc types: a value of another type reaching a typed slot,
-    // a call with the wrong arity, and a subclass member that does not
-    // match its base.
-    const projectCheckJs = load.typeWorld?.projectCheckJs ?? false;
-    const enforcedInCheckedJs = (p, d) => {
-        if (!CHECKED_JS_ENFORCED_CODES.has(d.code) || d.fileName === undefined)
-            return false;
-        const sf = p.getSourceFile(d.fileName);
-        return sf !== undefined && isCheckedJsSourceFile(sf, projectCheckJs);
-    };
-    // keptErrors drops every diagnostic of these files: the gate does not ask
-    // the checker for them.
-    const diagnosticsKept = (fileName) => npmStaticPackageOfPath(fileName) === null &&
-        !unselectedPackageJsFile(fileName) &&
-        !isPackageShimFile(fileName);
-    const errorsOf = (p) => keptErrors(p, ts.getPreEmitDiagnostics(p, diagnosticsKept));
-    const keptErrors = (p, all) => {
-        // First pass: every comment-side 2300's (file, name) — the partners
-        // the second pass forgives.
-        const commentDup = new Set();
-        for (const d of all) {
-            if (d.code !== 2300 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
-                continue;
-            if (!isJsSourceFileName(d.fileName))
-                continue;
-            const sf = p.getSourceFile(d.fileName);
-            if (sf && insideBlockComment(sf.text, d.pos))
-                commentDup.add(`${d.fileName}:${sf.text.slice(d.pos, d.end)}`);
-        }
-        return all.filter((d) => d.category === ts.DiagnosticCategory.Error &&
-            (!suppressedJsStrictness7(d) || enforcedInCheckedJs(p, d)) &&
-            !npmStaticFileSuppressed(d) &&
-            !nodeModulesJsSuppressed(d) &&
-            (d.fileName === undefined || !isPackageShimFile(d.fileName)) &&
-            !namespaceCalleeSuppressed(p, d) &&
-            !inferredJsDiagnosticSuppressed(p, d) &&
-            !isNpmStaticSubclassArgument(p, d) &&
-            !workspaceImplicitAnySuppressed(p, d) &&
-            !typeofTestedNameSuppressed(p, d) &&
-            !cjsTopLevelReturnSuppressed(p, d) &&
-            !jsdocTypeSuppressed(p, d, commentDup));
-    };
-    // The tsc gate, with a second chance: the LOWERING world's checker
-    // includes the divergence overrides (JSON.parse(): unknown, the Promise
-    // executor shape, ...), which are TIGHTER than the standard lib — a
-    // project that typechecks clean under its own tsc can still error here
-    // (any-typed JSON.parse results, most commonly). Those errors are OURS,
-    // not the project's, so they must not fail preflight: when the lowering
-    // world has errors, the PROJECT world (same program without the override
-    // declarations) is built and consulted. Clean there → preflight passes
-    // and the override-affected sites meet the lowerer's honest fences
-    // instead (the SC1100 checked-cast family). Dirty there → the project-
-    // world errors are the ones reported: they are reproducible with the
-    // project's own tsc, which is what "fix type errors first" asks for.
-    // With JSX sources, the program over the original text answers the tsc
-    // gate; its positions move into the rewritten text the program holds.
-    // Errors only the rewritten text has come from the calls the JSX lowers
-    // to (a factory whose signature does not accept them).
-    const tscWorld = load.tscWorld;
-    const tscErrors = tscWorld === undefined ? errorsOf(program) : keptErrors(tscWorld.program, tscWorld.diagnostics);
-    if (tscErrors.length > 0) {
-        const world = tscWorld === undefined || tscWorld.declWorldFallback === true
-            ? load.projectWorld()
-            : (tscWorld.projectWorld ?? tscWorld.program);
-        for (const d of errorsOf(world)) {
-            const diag = toPassthrough(d);
-            const lowered = tscWorld === undefined ? undefined : load.jsxSources?.get(diag.loc.file);
-            if (lowered !== undefined) {
-                diag.loc = {
-                    ...diag.loc,
-                    start: lowered.rewrittenPosition(diag.loc.start, false),
-                    end: lowered.rewrittenPosition(diag.loc.end, true),
-                };
-            }
-            diags.push(diag);
-        }
-    }
-    else if (load.jsxSources !== undefined) {
-        for (const file of load.jsxSources.keys()) {
-            const sf = program.getSourceFile(file);
-            if (sf === undefined)
-                continue;
-            const own = [...program.getSyntacticDiagnostics(sf), ...program.getSemanticDiagnostics(sf)];
-            for (const d of keptErrors(program, own)) {
-                const diag = toPassthrough(d);
-                diag.message = `${diag.message} (in the call this JSX lowers to)`;
-                diags.push(diag);
-            }
-        }
-    }
-    // Preflight and lowering share this CheckerFacade. Claim executable
-    // source files after workspace discovery and the tsc gate but before
-    // structural preflight checker queries, so a miss cannot trigger the old
-    // whole-file sweep (and eagerly fetch every dead body's answers). The
-    // structure wave includes declaration headers and top-level code;
-    // reachable bodies are added by lowering's worklists.
-    const ambient = ambientDtsPath();
-    const programFiles = program
-        .getImplementationSourceFiles()
-        .filter((sf) => sf.fileName !== ambient &&
-        !sf.isDeclarationFile &&
-        !sf.fileName.endsWith(".json") &&
-        (!isNodeModulesPath(sf.fileName) ||
-            entryPackageFile(sf.fileName) ||
-            npmStaticPackageOfPath(sf.fileName) !== null) &&
-        !unselectedPackageJsFile(sf.fileName));
-    // Files reached only through `import type` / `export type … from` are
-    // checker input, never program modules: Node does not load them, so
-    // their imports and syntax must not fence the program.
-    const resolveRuntimeEdge = (sf, spec, resolutionKind) => resolveImport7(program, sf, spec, resolutionKind) ??
-        npmStaticDepSf7(program, sf, spec, resolutionKind);
-    const typeOnlyFiles = typeOnlyReachedFiles(program, entry, programFiles, () => [
-        ...forkTargetPaths(program, program.getImplementationSourceFiles()),
-        ...workerTargetPaths(program, program.getImplementationSourceFiles()),
-    ], resolveRuntimeEdge);
-    const runtimeFiles = typeOnlyFiles.size === 0 ? programFiles : programFiles.filter((sf) => !typeOnlyFiles.has(sf));
-    const userFiles = npmStaticActive()
-        ? planNpmStaticReexports(program, entry, runtimeFiles, [
-            ...createRequireProgramRoots7(program),
-            ...forkTargetPaths(program, program.getImplementationSourceFiles()),
-            ...workerTargetPaths(program, program.getImplementationSourceFiles()),
-        ], resolveRuntimeEdge)
-        : runtimeFiles;
-    program.getTypeChecker().prefetchSourceFileStructures(userFiles);
-    // Unselected node_modules JS is not native program source even when
-    // maxNodeModuleJsDepth pulled it into the checker (nodeModulesJsSuppressed).
-    // Node stops at the nearest package.json even when it is malformed, and
-    // an explicit CommonJS scope (or .cjs/.cts extension) disables ambiguous-
-    // file syntax detection entirely. TypeScript's bundler checker models
-    // neither loader rule, so restore them before any module-edge analysis:
-    // one malformed-scope diagnostic per package file, and one pointed syntax
-    // diagnostic per CommonJS source file.
-    const invalidPackageConfigs = new Set();
-    for (const sf of userFiles) {
-        const invalidConfig = nearestInvalidPackageJsonPath(sf.fileName);
-        if (invalidConfig !== null) {
-            if (!invalidPackageConfigs.has(invalidConfig)) {
-                invalidPackageConfigs.add(invalidConfig);
-                diags.push(invalidPackageConfigDiag(invalidConfig, { file: sf.fileName, start: 0, end: 0 }));
-            }
-            continue;
-        }
-        if (!isNodeEsmFile7(sf, program)) {
-            const marker = nodeEsmSyntaxMarker7(sf);
-            if (marker !== null)
-                diags.push(commonJsModuleSyntaxDiag(locOf7(marker)));
-        }
-    }
-    const ambientModules = new Set(SUPPORTED_NODE_MODULES);
-    // Ambient `declare module "name"` declarations anywhere in the program —
-    // exact names and `*` patterns — so the import fence can say "type
-    // surface only, no runtime module" instead of the generic package story.
-    // Computed lazily: the scan only runs when a bare-import fence is about
-    // to fire.
-    let ambientModuleDecls = null;
-    const ambientDeclared = (spec) => {
-        if (ambientModuleDecls === null) {
-            ambientModuleDecls = { names: new Set(), patterns: [] };
-            for (const f of program.getSourceFiles()) {
-                for (const s of f.statements.nodes) {
-                    if (!ts.isModuleDeclaration(s) || !ts.isStringLiteral(s.name))
-                        continue;
-                    const name = s.name.text;
-                    if (name.includes("*"))
-                        ambientModuleDecls.patterns.push(name);
-                    else
-                        ambientModuleDecls.names.add(name);
-                }
-            }
-        }
-        if (ambientModuleDecls.names.has(spec))
-            return true;
-        return ambientModuleDecls.patterns.some((p) => {
-            const star = p.indexOf("*");
-            return (spec.length >= p.length - 1 &&
-                spec.startsWith(p.slice(0, star)) &&
-                spec.endsWith(p.slice(star + 1)));
-        });
+        return ambientModuleDecls.patterns.some((p) => {
+            const star = p.indexOf("*");
+            return (spec.length >= p.length - 1 &&
+                spec.startsWith(p.slice(0, star)) &&
+                spec.endsWith(p.slice(star + 1)));
+        });
     };
     // Module edges. An edge that closes a cycle is judged by the shared
     // admission engine (makeCycleAdmission): admissible when nothing can
@@ -5385,6 +5401,15 @@ function preflight7(load) {
                         continue;
                     }
                 }
+                // A re-export whose specifier resolves ONLY to a declaration file
+                // has no runtime module to link (Node throws
+                // ERR_MODULE_NOT_FOUND), and a declaration file is not a program
+                // module: an edge to it would lower the declarations' own imports
+                // as code.
+                if (reDep !== null && reDep.isDeclarationFile && !declarationHasRuntimeFile(reDep)) {
+                    diags.push(unsupportedDiag("SC1010", locOf7(stmt), `the '${fromSpec}' re-export (it resolves only to type declarations — there is no runtime implementation to compile)`));
+                    continue;
+                }
                 if (reDep && !reDep.fileName.endsWith(".json")) {
                     deps.push({ dep: reDep, stmt });
                     depPositions.get(sf).push({ dep: reDep, pos: ts.tokenStartOfNode(stmt) });
@@ -5395,6 +5420,12 @@ function preflight7(load) {
                 continue;
             if (erasedTypeOnlyImport(stmt))
                 continue;
+            // `import source x from "./x.wasm"` (TypeScript 7.1) binds the module's source object, such
+            // as a WebAssembly.Module; compiled programs do not support it yet.
+            if (isSourcePhaseImport(stmt.importClause)) {
+                diags.push(unsupportedDiag("SC1090", locOf7(stmt), "source phase imports (`import source`)"));
+                continue;
+            }
             // Import-like nodes whose specifier the parse could not shape into a
             // string literal — the jsdoc `/** @import x = require(...) */`
             // materialization and `import defer type * as ns` both arrive here
@@ -5440,12 +5471,30 @@ function preflight7(load) {
             // 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 by the project arm above.
-            const npm = isBare && projDep === null && !spec.startsWith("#")
-                ? resolveNpmImport7(sf.fileName, spec)
-                : null;
+            const projectAnswer = isBare ? resolveImport7(program, sf, spec) : null;
+            let projDep = projectAnswer;
+            let npm = null;
+            if (isBare && !spec.startsWith("#")) {
+                // A tsconfig `paths` target can name an installed package's directory
+                // (pi maps "typebox": ["./node_modules/typebox"]): its declarations
+                // are the package's own, so Node resolves the same specifier to the
+                // same answer and the import is an npm import after all. The npm arm
+                // below owns it then — its runtime refusal, npm-static membership and
+                // island policy included. A mapping whose answer the npm resolver does
+                // not reproduce stays a project import (and its SC1010).
+                const installed = projectAnswer !== null &&
+                    projectAnswer.isDeclarationFile &&
+                    isNodeModulesPath(projectAnswer.fileName)
+                    ? resolveNpmImport7(sf.fileName, spec)
+                    : null;
+                if (installed !== null && sameResolvedFile(installed.typesFile, projectAnswer.fileName)) {
+                    projDep = null;
+                    npm = installed;
+                }
+                else if (projectAnswer === null) {
+                    npm = resolveNpmImport7(sf.fileName, spec);
+                }
+            }
             if (npm && isNodeTypesPath(npm.typesFile)) {
                 diags.push(unsupportedDiag("SC1010", locOf7(stmt), unsupportedModuleFeatureOf(spec)));
                 continue;
@@ -5539,6 +5588,16 @@ function preflight7(load) {
             const clause = stmt.importClause;
             const dep = isRelative ? resolveImport7(program, sf, spec) : (npmStaticDep ?? projDep);
             const isJson = dep !== null && dep.fileName.endsWith(".json");
+            // A specifier that resolves ONLY to a declaration file has no runtime
+            // module to link: Node throws ERR_MODULE_NOT_FOUND at this import.
+            // Declarations are not program modules — taking one as a module-order
+            // edge would lower its imports as if it were code (SC2013 for every
+            // specifier inside a package's `.d.ts`). Type-only imports were
+            // already erased above; this is the value form.
+            if (dep !== null && dep.isDeclarationFile && !isJson && !declarationHasRuntimeFile(dep)) {
+                diags.push(unsupportedDiag("SC1010", locOf7(stmt), `the '${spec}' import (it resolves only to type declarations — there is no runtime implementation to compile)`));
+                continue;
+            }
             // SELF-imports: the bindings alias this module's OWN declarations,
             // so a TOP-LEVEL read lexically above the aliased declaration is
             // Node's TDZ ReferenceError at runtime (exactly what tsc's TS2448
@@ -5775,6 +5834,11 @@ function preflight7(load) {
                     }
                     if (earlyRequireFence(req, bindingKind, loc))
                         continue;
+                    // A declaration file is never a runtime module (see the import
+                    // arm): the require throws MODULE_NOT_FOUND in Node, so it is not
+                    // a module-order edge.
+                    if (dep !== null && dep.isDeclarationFile)
+                        continue;
                     if (dep)
                         deps.push({ dep });
                 }
@@ -5855,7 +5919,7 @@ function preflight7(load) {
                     const edgeTo = (dep) => lazy ? { dep, lazy: true, call } : { dep, call };
                     const projectDep = resolveImport7(program, sf, spec, "require");
                     if (projectDep !== null) {
-                        if (!projectDep.fileName.endsWith(".json"))
+                        if (!projectDep.fileName.endsWith(".json") && !projectDep.isDeclarationFile)
                             deps.push(edgeTo(projectDep));
                         continue;
                     }
@@ -5953,6 +6017,7 @@ function preflight7(load) {
     // Node's fetch/resolve phase runs before instantiate.
     let resolveCrash = null;
     const dynamicImportRejections = new Map();
+    const fallbacks = [];
     {
         const seen = new Set();
         const walk = (sf) => {
@@ -6025,29 +6090,389 @@ function preflight7(load) {
         // preflight: when any other diagnostic already fails the build, every
         // refusal keeps its compile-fence fallback instead — the report names
         // each import's story, so edges whose crash will never compile still
-        // get a diagnostic. (No reachable refusal → same: fallbacks only.)
-        if (resolveCrash === null || diags.length > 0) {
-            resolveCrash = null;
-            for (const [sf, cands] of refusals) {
-                if (covered.has(sf) && !startup.has(sf))
-                    continue;
-                for (const c of cands)
-                    diags.push(c.fallback);
-            }
+        // get a diagnostic. (No reachable refusal → same: fallbacks only.) The
+        // "otherwise pass" half of that question is preflightDiagnostics7's:
+        // it alone sees the tsc gate's diagnostics, so it reports `fallbacks`.
+        for (const [sf, cands] of refusals) {
+            if (covered.has(sf) && !startup.has(sf))
+                continue;
+            for (const c of cands)
+                fallbacks.push(c.fallback);
         }
     }
-    const linkCrash = resolveCrash !== null
-        ? null
-        : earlierLinkCrash(order, cjsNamedImportLinkCheck(program, entry, order, diags), esmNamedImportLinkCheck(program, entry, order, diags));
     return {
-        diags,
-        moduleOrder: order,
-        startupCrash: resolveCrash ?? linkCrash,
-        inlineRequireCycleCalls,
+        order,
         moduleEdges: edges,
         dynamicImportRejections,
+        inlineRequireCycleCalls,
+        diags,
+        resolveCrash,
+        fallbacks,
+    };
+}
+/** The whole preflight for one load: the tsc gate, the module graph walk and
+ * every diagnostic they report, in report order. The structure is memoized,
+ * so a caller that asked for the order first (checkModuleOrder) pays for the
+ * walk once. */
+function preflight7(load) {
+    registerWorkspaceEdges(load);
+    const gate = preflightGate7(load);
+    const structure = preflightStructure(load);
+    const { diags, startupCrash } = preflightDiagnostics7(load, structure, gate.diags);
+    return {
+        diags,
+        moduleOrder: structure.order,
+        startupCrash,
+        inlineRequireCycleCalls: structure.inlineRequireCycleCalls,
+        moduleEdges: structure.moduleEdges,
+        dynamicImportRejections: structure.dynamicImportRejections,
+        admittedOpinions: gate.admittedOpinions,
     };
 }
+/** The diagnostics half of preflight: the tsc gate ahead of the walk's own
+ * diagnostics, then the passes that judge the completed module order. The
+ * tsc gate runs first on every load whose order was not requested on its
+ * own, exactly as it did inside the single pass. */
+function preflightDiagnostics7(load, structure, gate) {
+    const { program, entry } = load;
+    const order = structure.order;
+    const diags = [...load.configDiags];
+    for (const d of gate)
+        diags.push(d);
+    for (const d of structure.diags)
+        diags.push(d);
+    // ECMAScript's sloppy-mode WRITE to an undeclared name, which the JS
+    // relaxation above admits for READS (plan D-2): refused by name, with the
+    // island route in the text (SC1091).
+    for (const d of jsUndeclaredWriteDiags(program, order))
+        diags.push(d);
+    // The crash channel engages only when nothing else fails preflight.
+    let startupCrash = structure.resolveCrash;
+    if (startupCrash === null || diags.length > 0) {
+        startupCrash = null;
+        for (const d of structure.fallbacks)
+            diags.push(d);
+    }
+    const linkCrash = startupCrash !== null
+        ? null
+        : earlierLinkCrash(order, cjsNamedImportLinkCheck(program, entry, order, diags), esmNamedImportLinkCheck(program, entry, order, diags));
+    // ECMAScript early errors the TypeScript checker does not model (plan
+    // §7.7 D-4): a JavaScript source the spec makes a SyntaxError fails here,
+    // before any lowering, exactly where a tsc parse error fails.
+    diags.push(...earlyErrorDiagnostics7(order, (sf) => isNodeEsmFile7(sf, program)));
+    return { diags, startupCrash: startupCrash ?? linkCrash };
+}
+function preflightGate7(load) {
+    const { program, entry } = load;
+    const diags = [];
+    const unselectedPackageJsFile = unselectedPackageJsFilePredicate(entry.fileName);
+    const toPassthrough = (d) => {
+        const message = ts.flattenDiagnosticMessageText(d, "\n");
+        // File-less (global/options) diagnostics anchor at the entry with a
+        // zero span, exactly like the 5.9.3 lane's `d.start ?? 0` fallback.
+        const file = d.fileName ?? entry.fileName;
+        const start = d.fileName !== undefined ? d.pos : 0;
+        const end = d.fileName !== undefined ? d.end : 0;
+        // A JavaScript source's `refuse`/`rewrite` code names the construct
+        // scriptc does not lower (tsc-codes.ts): the user sees what is missing
+        // instead of TypeScript's opinion about legal JavaScript.
+        const triaged = d.fileName !== undefined && isJsSourceFileName(d.fileName) ? jsTscCodeTriage(d.code) : null;
+        if (triaged?.action === "refuse" || triaged?.action === "rewrite") {
+            const diag = unsupportedDiag("SC1090", { file, start, end }, triaged.feature, `${triaged.hint} (TypeScript reports TS${d.code} here.)`);
+            return diag;
+        }
+        const diag = tscPassthroughDiag(message, { file, start, end });
+        const hint = typeWorldHint(d, message, load);
+        if (hint !== null) {
+            diag.typeWorld = true;
+            diag.hint = hint;
+        }
+        return diag;
+    };
+    /* TS7 checker change (not finding 5, same discipline): tsgo types a
+     * NAMESPACE import as the spec's non-callable module namespace object
+     * even when the module is declared with the callable `export =` shape —
+     * 5.9.3 bound the callable value directly, so `import * as a from
+     * "node:assert"; a(x)` typechecked there and draws TS2349 here. Those
+     * callable module objects are scriptc's OWN declared surface, and calls
+     * through the namespace binding are fenced per site by the lowering (the
+     * assert-fences fixture pins the wording), so tsgo's extra TS2349 on
+     * exactly those callees — an identifier that is a namespace-import
+     * binding of a supported builtin module — is suppressed to the 5.9.3
+     * verdict. Nothing else rides this: any other non-callable call keeps
+     * tsc's voice in both lanes. */
+    const builtinNamespaceNames = new Map();
+    const namespaceCalleeSuppressed = (p, d) => {
+        if (d.code !== 2349 || d.fileName === undefined)
+            return false;
+        let names = builtinNamespaceNames.get(d.fileName);
+        if (!names) {
+            names = new Set();
+            builtinNamespaceNames.set(d.fileName, names);
+            const sf = p.getSourceFile(d.fileName);
+            for (const stmt of sf?.statements?.nodes ?? []) {
+                if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
+                    continue;
+                if (canonicalBuiltinModule(stmt.moduleSpecifier.text) === null)
+                    continue;
+                const bindings = stmt.importClause?.namedBindings;
+                if (bindings && ts.isNamespaceImport(bindings))
+                    names.add(bindings.name.text);
+            }
+        }
+        if (names.size === 0)
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        return sf !== undefined && names.has(sf.text.slice(d.pos, d.end));
+    };
+    const npmStaticFileSuppressed = (d) => d.fileName !== undefined && npmStaticPackageOfPath(d.fileName) !== null;
+    const nodeModulesJsSuppressed = (d) => d.fileName !== undefined && unselectedPackageJsFile(d.fileName);
+    /* JSDoc TYPE positions in JS files are documentation Node never reads:
+     * a name-resolution failure THERE (2304/2552 — the pattern's utilities.js
+     * spells a mapped type over a @template name it never declared) types
+     * as the error-any and the per-site fences apply, same stance as the
+     * strictness families above. A 2300 duplicate-identifier PAIR formed by
+     * a @typedef and a same-named class/function is the same story — the
+     * typedef half sits inside the comment, and the code half is suppressed
+     * exactly when its partner (same file, same name) was comment-side, so
+     * a REAL duplicate declaration (both halves in code — Node's own
+     * SyntaxError) keeps tsc's voice. */
+    const insideBlockComment = (text, pos) => {
+        const open = text.lastIndexOf("/*", pos);
+        if (open < 0)
+            return false;
+        const close = text.indexOf("*/", open + 2);
+        return close === -1 || close >= pos;
+    };
+    const jsdocTypeSuppressed = (p, d, commentDup) => {
+        if (d.fileName === undefined || !isJsSourceFileName(d.fileName))
+            return false;
+        if (d.code !== 2304 && d.code !== 2552 && d.code !== 2300 && d.code !== 1003)
+            return false;
+        if (d.pos === undefined)
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        if (!sf)
+            return false;
+        if (insideBlockComment(sf.text, d.pos))
+            return true;
+        return d.code === 2300 && commentDup.has(`${d.fileName}:${sf.text.slice(d.pos, d.end)}`);
+    };
+    /* `typeof window` / `typeof self` in a JavaScript file: the operand of
+     * typeof may name a global nothing declares (Node answers "undefined"
+     * and never throws), the feature-detection idiom every isomorphic
+     * package uses, and the guarded uses of that name (`typeof window < "u"
+     * ? window : …`) are code Node never runs. A name the file feature-tests
+     * this way is therefore not a type error in JavaScript; a reached use
+     * still meets the lowering's located refusal. TypeScript files keep the
+     * error and its hint. */
+    const typeofTestedNameSuppressed = (p, d) => {
+        if (d.code !== 2304 && d.code !== 2552 && d.code !== 2584)
+            return false;
+        if (d.fileName === undefined || !isJsSourceFileName(d.fileName))
+            return false;
+        if (d.pos === undefined || d.end === undefined)
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        if (!sf)
+            return false;
+        const name = sf.text.slice(d.pos, d.end);
+        if (!/^[A-Za-z_$][\w$]*$/.test(name))
+            return false;
+        return new RegExp(`\\btypeof\\s*\\(?\\s*${name.replace(/\$/g, "\\$")}(?![\\w$])`).test(sf.text);
+    };
+    // A `return` at the top level of a CommonJS module (TS1108): Node runs
+    // the module as a function body, so the return ends the module's
+    // evaluation. ES modules and TypeScript keep the error.
+    const cjsTopLevelReturnSuppressed = (p, d) => {
+        if (d.code !== 1108 || d.fileName === undefined || !isJsSourceFileName(d.fileName))
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        return sf !== undefined && isCjsJsFile7(sf, p);
+    };
+    const workspaceImplicitAnySuppressed = (p, d) => {
+        if (d.code !== 7016 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        if (!sf)
+            return false;
+        const spec = sf.text.slice(d.pos, d.end).replace(/^['"]|['"]$/g, "");
+        const prefix = spec.startsWith("@")
+            ? spec.split("/").slice(0, 2).join("/")
+            : spec.split("/")[0];
+        return isWorkspacePackageName(prefix);
+    };
+    // A JavaScript file that TypeScript checks keeps the type errors that
+    // protect its JSDoc types: a value of another type reaching a typed slot,
+    // a call with the wrong arity, and a subclass member that does not
+    // match its base (the rows that say `checkedJs: "enforce"` in
+    // JS_OPINIONS).
+    const projectCheckJs = load.typeWorld?.projectCheckJs ?? false;
+    // The opinion sites this preflight admits (tsc-codes.ts, JS_OPINIONS),
+    // deduped across the worlds the gate consults (the lowering world, the
+    // project world, the JSX text). The lowering asks opinionAt about one of
+    // them; a view's lowering path is gated on the record, never on syntax.
+    const admittedOpinions = new Map();
+    const recordAdmittedOpinion = (site) => {
+        admittedOpinions.set(`${site.file}\0${site.pos}\0${site.end}\0${site.code}`, site);
+    };
+    // A diagnostic's span is an offset into the text of the program that
+    // answered it. With JSX sources the gate's worlds hold the files as
+    // written, while the lowering asks opinionAt about nodes of `program`,
+    // which carries the rewritten text; an original offset recorded as a site
+    // would name an unrelated node wherever a rewrite moved the text. The span
+    // moves into that text exactly as a reported diagnostic's location does
+    // below: copied text keeps its offset, a span inside JSX maps to the call
+    // it lowered to.
+    const admittedSite = (p, site) => {
+        if (p === program)
+            return site;
+        const lowered = load.jsxSources?.get(site.file);
+        if (lowered === undefined)
+            return site;
+        return {
+            ...site,
+            pos: lowered.rewrittenPosition(site.pos, false),
+            end: lowered.rewrittenPosition(site.end, true),
+        };
+    };
+    // keptErrors drops every diagnostic of these files: the gate does not ask
+    // the checker for them.
+    const diagnosticsKept = (fileName) => npmStaticPackageOfPath(fileName) === null &&
+        !unselectedPackageJsFile(fileName) &&
+        !isPackageShimFile(fileName);
+    const errorsOf = (p) => keptErrors(p, ts.getPreEmitDiagnostics(p, diagnosticsKept));
+    const keptErrors = (p, all) => {
+        // First pass: every comment-side 2300's (file, name) — the partners
+        // the second pass forgives.
+        const commentDup = new Set();
+        for (const d of all) {
+            if (d.code !== 2300 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
+                continue;
+            if (!isJsSourceFileName(d.fileName))
+                continue;
+            const sf = p.getSourceFile(d.fileName);
+            if (sf && insideBlockComment(sf.text, d.pos))
+                commentDup.add(`${d.fileName}:${sf.text.slice(d.pos, d.end)}`);
+        }
+        // The syntactic diagnostics of a JS file, asked for only when a
+        // diagnostic names a code an opinion row covers.
+        const syntactic = new Map();
+        const syntacticOf = (sf) => {
+            let list = syntactic.get(sf.fileName);
+            if (list === undefined) {
+                list = p.getSyntacticDiagnostics(sf);
+                syntactic.set(sf.fileName, list);
+            }
+            return list;
+        };
+        // The older filters that answer from the file name, the source text or
+        // the syntax alone. The recording pass below uses this subset: the two
+        // filters that ask the CHECKER a question
+        // (inferredJsDiagnosticSuppressed, isNpmStaticSubclassArgument) are
+        // deliberately not consulted for an admitted diagnostic. Before this
+        // table, an admitted diagnostic was dropped before the chain reached
+        // them, so asking now would add a checker query a program's compile
+        // never made — and tsgo answers the query on a destructuring pattern
+        // with a panic ("Value is not an instance of 'TupleType'"), which is how
+        // this slice's Test262 replay first failed. The kept path still consults
+        // every filter, in the order it always did.
+        const keptApartFromOpinionTextually = (d) => !npmStaticFileSuppressed(d) &&
+            !nodeModulesJsSuppressed(d) &&
+            (d.fileName === undefined || !isPackageShimFile(d.fileName)) &&
+            !namespaceCalleeSuppressed(p, d) &&
+            !workspaceImplicitAnySuppressed(p, d) &&
+            !typeofTestedNameSuppressed(p, d) &&
+            !cjsTopLevelReturnSuppressed(p, d) &&
+            !jsdocTypeSuppressed(p, d, commentDup);
+        // Every filter except the opinion admission, in its historical order.
+        const keptApartFromOpinion = (d) => keptApartFromOpinionTextually(d) &&
+            !inferredJsDiagnosticSuppressed(p, d) &&
+            !isNpmStaticSubclassArgument(p, d);
+        const admitted = [];
+        const kept = all.filter((d) => {
+            if (d.category !== ts.DiagnosticCategory.Error)
+                return false;
+            // The 8xxx range is TypeScript's JSDoc-specific diagnostic family
+            // (malformed tags, signature/tag mismatches): comment semantics with no
+            // runtime meaning in a JS file, and no lowering view to record.
+            if (d.fileName !== undefined &&
+                isJsSourceFileName(d.fileName) &&
+                d.code >= 8000 &&
+                d.code <= 8999)
+                return false;
+            const opinion = jsOpinionOf7(p, d, projectCheckJs, syntacticOf);
+            if (opinion !== null) {
+                admitted.push({ d, opinion });
+                return false;
+            }
+            return keptApartFromOpinion(d);
+        });
+        for (const { d, opinion } of admitted) {
+            // No span, no site: nothing a view's lowering could be gated on.
+            if (d.fileName === undefined || d.pos === undefined || d.end === undefined)
+                continue;
+            if (keptApartFromOpinionTextually(d))
+                recordAdmittedOpinion(admittedSite(p, {
+                    file: d.fileName,
+                    pos: d.pos,
+                    end: d.end,
+                    code: d.code,
+                    view: opinion.view,
+                }));
+        }
+        return kept;
+    };
+    // The tsc gate, with a second chance: the LOWERING world's checker
+    // includes the divergence overrides (JSON.parse(): unknown, the Promise
+    // executor shape, ...), which are TIGHTER than the standard lib — a
+    // project that typechecks clean under its own tsc can still error here
+    // (any-typed JSON.parse results, most commonly). Those errors are OURS,
+    // not the project's, so they must not fail preflight: when the lowering
+    // world has errors, the PROJECT world (same program without the override
+    // declarations) is built and consulted. Clean there → preflight passes
+    // and the override-affected sites meet the lowerer's honest fences
+    // instead (the SC1100 checked-cast family). Dirty there → the project-
+    // world errors are the ones reported: they are reproducible with the
+    // project's own tsc, which is what "fix type errors first" asks for.
+    // With JSX sources, the program over the original text answers the tsc
+    // gate; its positions move into the rewritten text the program holds.
+    // Errors only the rewritten text has come from the calls the JSX lowers
+    // to (a factory whose signature does not accept them).
+    const tscWorld = load.tscWorld;
+    const tscErrors = tscWorld === undefined ? errorsOf(program) : keptErrors(tscWorld.program, tscWorld.diagnostics);
+    if (tscErrors.length > 0) {
+        const world = tscWorld === undefined || tscWorld.declWorldFallback === true
+            ? load.projectWorld()
+            : (tscWorld.projectWorld ?? tscWorld.program);
+        for (const d of errorsOf(world)) {
+            const diag = toPassthrough(d);
+            const lowered = tscWorld === undefined ? undefined : load.jsxSources?.get(diag.loc.file);
+            if (lowered !== undefined) {
+                diag.loc = {
+                    ...diag.loc,
+                    start: lowered.rewrittenPosition(diag.loc.start, false),
+                    end: lowered.rewrittenPosition(diag.loc.end, true),
+                };
+            }
+            diags.push(diag);
+        }
+    }
+    else if (load.jsxSources !== undefined) {
+        for (const file of load.jsxSources.keys()) {
+            const sf = program.getSourceFile(file);
+            if (sf === undefined)
+                continue;
+            const own = [...program.getSyntacticDiagnostics(sf), ...program.getSemanticDiagnostics(sf)];
+            for (const d of keptErrors(program, own)) {
+                const diag = toPassthrough(d);
+                diag.message = `${diag.message} (in the call this JSX lowers to)`;
+                diags.push(diag);
+            }
+        }
+    }
+    return { diags, admittedOpinions: [...admittedOpinions.values()] };
+}
 /* ── the CJS named-import link check ─────────────────────────────────────
  * Node builds a CommonJS module's ESM facade from its LEXER (cjs-lexer.ts
  * mirrors it), never from execution — so a named import the checker binds
@@ -6642,7 +7067,7 @@ const nodeBuiltinNames = new Set(builtinModules);
 export { ambientDtsPath, fallbackDtsPath, isFallbackDtsPath, isNodeTypesPath, overridesDtsPath, } from "./dts-paths.js";
 export { builtinDefaultImportModule, canonicalBuiltinModule, npmBuiltinAliasOf, SUPPORTED_BUILTIN_MODULES, } from "./builtin-modules.js";
 export { npmPackageNameOf, workspacePackageOfPath } from "./workspace-registry.js";
-export { requireSpecOf7 as requireSpecOf, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, splitRequireCallOf7 as splitRequireCallOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
+export { requireSpecOf7 as requireSpecOf, requireCallBindingKind7 as requireCallBindingKind, isRequireStatement7 as isRequireStatement, requiresOf7 as requiresOf, splitRequireCallOf7 as splitRequireCallOf, isNodeEsmFile7 as isNodeEsmFile, resolveImport7 as resolveImport, resolveNpmImport7 as resolveNpmImport, locOf7 as locOf, requireEarlyReference7 as requireEarlyReference, inDeferredPosition7 as inDeferredPosition, };
 /** True for JavaScript source files (.js/.mjs/.cjs) — the files whose
  * types come entirely from inference (checkJs + JSDoc) and whose classes
  * declare fields by constructor assignment. */