@scriptc/compiler 0.1.3 → 0.1.5

package/dist/frontend/program.js

@@ -45,6 +45,7 @@ import { commonJsModuleSyntaxDiag, invalidPackageConfigDiag, strictNullChecksFlo
 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, setNpmStaticDeclarationOverloads, setNpmStaticPackages } from "./npm-static.js";
+import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.js";
 import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties } from "./npm-static-declarations.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
 import { cjsLexerVisibleNames } from "./cjs-lexer.js";
@@ -53,6 +54,7 @@ import { builtinDefaultImportModule, canonicalBuiltinModule, SUPPORTED_NODE_MODU
 import { clearWorkspacePackages, isRelativeSpecifier, isWorkspacePackageName, npmPackageNameOf, registerWorkspacePackage, workspacePackageOfPath, } from "./workspace-registry.js";
 import { ADOPTED_OPTIONS, isJsSourceFileName, JS_ANY_OPERATOR_CODES, JS_RELAXED_TSC_CODES, } from "./tsc-codes.js";
 import { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
+import { forkTargetPaths } from "./fork-target.js";
 const BASE_OPTIONS = {
     strict: true,
 };
@@ -344,6 +346,44 @@ function externalTypeFileClosure7(program, externalTypes) {
     }
     return new Map([...ownersByFile].map(([file, owners]) => [file, [...owners]]));
 }
+/** Program roots hidden behind canonical createRequire bindings. tsgo
+ * discovers ordinary import/require edges itself, but a source binding
+ * returned by createRequire is intentionally just a function to the type
+ * checker. Rebuild the native program with each literal project target as
+ * an explicit root, to a fixpoint, so the same TS 7 AST/checker world owns
+ * their exports and transitive graph. */
+function createRequireProgramRoots7(program) {
+    const known = new Set(program.getSourceFiles().map((sf) => tsgoPath(resolve(sf.fileName))));
+    const roots = new Set();
+    for (const sf of program.getSourceFiles()) {
+        if (sf.isDeclarationFile || sf.fileName.endsWith(".json"))
+            continue;
+        ts.walkPreorder(sf, (node) => {
+            if (!ts.isCallExpression(node) || node.questionDotToken !== undefined ||
+                node.arguments.length !== 1 || !ts.isStringLiteralLike(node.arguments[0]) ||
+                !ts.isIdentifier(node.expression) || !isCreateRequireBinding7(program, node.expression)) {
+                return undefined;
+            }
+            const spec = node.arguments[0].text;
+            if (canonicalBuiltinModule(spec) !== null)
+                return "skip";
+            let target = resolveProjectModule(sf.fileName, spec);
+            if (target === null && !spec.startsWith("#")) {
+                const npm = resolveNpmImport7(sf.fileName, spec);
+                if (npm !== null && isNpmStaticPackage(npm.packageName) && isJsSourceFileName(npm.typesFile)) {
+                    target = npm.typesFile;
+                }
+            }
+            if (target === null || target.endsWith(".json"))
+                return "skip";
+            const normalized = tsgoPath(resolve(target));
+            if (!known.has(normalized))
+                roots.add(normalized);
+            return "skip";
+        });
+    }
+    return [...roots].sort();
+}
 function loadProgram7(host, entryPath, externalTypes = new Map()) {
     const config = adoptProjectConfig7(host, entryPath);
     const configuredPaths = config.options["paths"];
@@ -361,8 +401,10 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
     // just resolved) — without maxNodeModuleJsDepth, node_modules JS types as
     // an implicit-any module (TS7016) and nothing infers. Only flagged
     // compiles pay this; flagless builds keep the exact historical options.
+    // Eight levels retain package-internal re-export chains such as Effect's;
+    // the former four-level cap left valid bindings outside the checker graph.
     if (npmStaticActive())
-        options.maxNodeModuleJsDepth = 4;
+        options.maxNodeModuleJsDepth = 8;
     // --provenance-sources: the registered entries become tsconfig "paths"
     // so tsgo's OWN resolution of the bare specifiers lands on the same
     // source files the preflight resolver answers — the checker types the
@@ -379,7 +421,22 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
         options = { ...options, paths };
     }
     const coreRoots = [entryPath, ambientDtsPath(), nodeTypes ?? fallbackDtsPath()];
-    const program = ts.createProgram([...coreRoots, overridesDtsPath()], options, host);
+    const programRoots = [...coreRoots];
+    let program = ts.createProgram([...programRoots, overridesDtsPath()], options, host);
+    for (let pass = 0; pass < 32; pass++) {
+        const candidates = [
+            ...createRequireProgramRoots7(program),
+            ...forkTargetPaths(program, program.getSourceFiles()),
+        ];
+        const extraRoots = candidates.filter((root, index) => !programRoots.includes(root) && candidates.indexOf(root) === index);
+        if (extraRoots.length === 0)
+            break;
+        program.dispose();
+        programRoots.push(...extraRoots);
+        program = ts.createProgram([...programRoots, overridesDtsPath()], options, host);
+        if (pass === 31)
+            throw new Error("static program-root discovery did not converge");
+    }
     const entry = program.getSourceFile(entryPath);
     if (!entry)
         throw new Error(`could not load ${entryPath}`);
@@ -392,7 +449,7 @@ function loadProgram7(host, entryPath, externalTypes = new Map()) {
         configDiags: config.diags,
         externalTypes,
         externalTypeSpecifiersByFile,
-        projectWorld: () => (projectWorld ??= ts.createProgram(coreRoots, options, host)),
+        projectWorld: () => (projectWorld ??= ts.createProgram(programRoots, options, host)),
         disposeAll: () => {
             projectWorld?.dispose();
             program.dispose();
@@ -562,13 +619,18 @@ function suppressedJsStrictness7(d) {
  * share — anything require-shaped it does NOT match (computed specifiers,
  * extra arguments) is not a module edge and fences at its use site. */
 function requireSpecOf7(node) {
-    if (!ts.isCallExpression(node))
+    let value = node;
+    while (ts.isParenthesizedExpression(value) || ts.isAsExpression(value) ||
+        ts.isTypeAssertion(value) || ts.isNonNullExpression(value)) {
+        value = value.expression;
+    }
+    if (!ts.isCallExpression(value))
         return null;
-    if (!ts.isIdentifier(node.expression) || node.expression.text !== "require")
+    if (!ts.isIdentifier(value.expression) || value.expression.text !== "require")
         return null;
-    if (node.arguments.length !== 1)
+    if (value.arguments.length !== 1)
         return null;
-    const arg = node.arguments[0];
+    const arg = value.arguments[0];
     return ts.isStringLiteral(arg) ? arg.text : null;
 }
 /** True for statements that are CommonJS require IMPORTS at a module's top
@@ -806,7 +868,8 @@ function isCreateRequireBinding7(program, callee) {
  * module edges; other source bindings get a pointed fence before lowering
  * can mistake them for module syntax. */
 function requireCallBindingKind7(program, node) {
-    const call = ts.isVariableDeclaration(node) ? node.initializer : node;
+    const raw = ts.isVariableDeclaration(node) ? node.initializer : node;
+    const call = raw && ts.isExpression(raw) ? stripRequireCasts7(raw) : raw;
     if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
         return "ambient";
     const checker = program.getTypeChecker();
@@ -1853,13 +1916,15 @@ function preflight7(load) {
         !sf.fileName.endsWith(".json") &&
         (!isNodeModulesPath(sf.fileName) || npmStaticPackageOfPath(sf.fileName) !== null) &&
         !islandJsFile(sf.fileName));
-    program.getTypeChecker().prefetchSourceFileStructures(programFiles);
+    const userFiles = npmStaticActive()
+        ? planNpmStaticReexports(program, entry, programFiles, [...createRequireProgramRoots7(program), ...forkTargetPaths(program, program.getSourceFiles())], (sf, spec) => resolveImport7(program, sf, spec) ?? npmStaticDepSf7(program, sf, spec))
+        : programFiles;
+    program.getTypeChecker().prefetchSourceFileStructures(userFiles);
     // node_modules JS that no --npm-static opt-in claims is NOT program
     // source even when maxNodeModuleJsDepth pulled it into the checker's
     // program (see nodeModulesJsSuppressed above): its execution home is the
     // island, so preflight's statement walks skip it — no import fences, no
     // module edges, no statement counts from files the lowering never lowers.
-    const userFiles = programFiles;
     // 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
@@ -1963,7 +2028,7 @@ function preflight7(load) {
                 continue;
             }
             if (ts.isExportDeclaration(stmt)) {
-                if (stmt.isTypeOnly || erasedTypeOnlyReexport(stmt))
+                if (stmt.isTypeOnly || erasedTypeOnlyReexport(stmt) || isPrunedNpmReexport(program, stmt))
                     continue;
                 if (!stmt.moduleSpecifier)
                     continue;
@@ -2234,7 +2299,8 @@ function preflight7(load) {
                 depPositions.get(sf).push({ dep, pos: stmt.getStart(sf) });
             }
         }
-        if (isJsSourceFileName(sf.fileName)) {
+        {
+            const jsRequireFile = isJsSourceFileName(sf.fileName);
             const stmts = sf.statements;
             let firstRunnable = -1;
             stmts.forEach((s, i) => {
@@ -2245,8 +2311,14 @@ function preflight7(load) {
                 const stmt = stmts[k];
                 for (const req of requiresOf7(stmt)) {
                     const loc = { file: sf.fileName, start: req.node.getStart(sf), end: req.node.getEnd() };
+                    const bindingKind = requireCallBindingKind7(program, req.node);
+                    // TypeScript source files join this scan only through the
+                    // canonical createRequire bridge. Their ordinary require-shaped
+                    // calls retain the existing checker/lowering diagnostics; JS
+                    // files keep the full CommonJS scan.
+                    if (!jsRequireFile && bindingKind !== "createRequire")
+                        continue;
                     if (isNodeEsmFile7(sf)) {
-                        const bindingKind = requireCallBindingKind7(program, req.node);
                         if (bindingKind !== "createRequire") {
                             diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
                             continue;
@@ -2281,6 +2353,13 @@ function preflight7(load) {
                                 continue; // offender recorded — the fallback loop reloads
                         }
                         else {
+                            // createRequire's non-program targets belong to its own
+                            // lowering: installed packages select static-vs-island
+                            // there, and missing packages become catchable
+                            // MODULE_NOT_FOUND throws. Only resolved program targets are
+                            // module-order edges in this preflight walk.
+                            if (bindingKind === "createRequire")
+                                continue;
                             if (canonicalBuiltinModule(req.spec) === null &&
                                 !processModuleAliasRequire7(req.spec, req.decl)) {
                                 // A binding-less require of a package NOTHING resolves:
@@ -2297,6 +2376,8 @@ function preflight7(load) {
                         }
                     }
                     if (dep && dep.fileName.endsWith(".json")) {
+                        if (bindingKind === "createRequire")
+                            continue;
                         diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
                         continue;
                     }
@@ -2316,8 +2397,10 @@ function preflight7(load) {
             for (const call of nestedBareRequires) {
                 const spec = requireSpecOf7(call);
                 const loc = { file: sf.fileName, start: call.getStart(sf), end: call.getEnd() };
+                const bindingKind = requireCallBindingKind7(program, call);
+                if (!jsRequireFile && bindingKind !== "createRequire")
+                    continue;
                 if (isNodeEsmFile7(sf)) {
-                    const bindingKind = requireCallBindingKind7(program, call);
                     if (bindingKind !== "createRequire") {
                         diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
                         continue;
@@ -2329,6 +2412,8 @@ function preflight7(load) {
                 const projectDep = resolveImport7(program, sf, spec);
                 if (projectDep !== null) {
                     if (projectDep.fileName.endsWith(".json")) {
+                        if (bindingKind === "createRequire")
+                            continue;
                         diags.push(unsupportedDiag("SC1012", loc, "require() of JSON modules"));
                         continue;
                     }
@@ -2345,6 +2430,8 @@ function preflight7(load) {
                             deps.push({ dep: nDep });
                         continue;
                     }
+                    if (bindingKind === "createRequire")
+                        continue;
                     if (canonicalBuiltinModule(spec) === null && !processModuleAliasRequire7(spec, null)) {
                         // Binding-less by construction — same require-site throw
                         // channel as the statement-level form above.
@@ -2561,6 +2648,8 @@ function cjsNamedImportLinkCheck(program, entry, moduleOrder, diags) {
         for (const stmt of sf.statements) {
             if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
                 continue;
+            if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt))
+                continue;
             if (ts.isImportDeclaration(stmt) && stmt.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword)
                 continue;
             const specNode = stmt.moduleSpecifier;
@@ -2787,6 +2876,8 @@ function analyzeEsmNamedImportLinks(program, entry) {
         for (const stmt of sf.statements) {
             if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
                 continue;
+            if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt))
+                continue;
             if (ts.isImportDeclaration(stmt) && stmt.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword)
                 continue;
             const moduleSpecifier = stmt.moduleSpecifier;
@@ -2973,6 +3064,8 @@ function erasedTypeOnlyReexport(stmt) {
 export function orderedImportsOf(program, sf) {
     const out = [];
     for (const stmt of sf.statements) {
+        if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt))
+            continue;
         if (ts.isExportDeclaration(stmt) && (stmt.isTypeOnly || erasedTypeOnlyReexport(stmt) || !stmt.moduleSpecifier))
             continue;
         if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt))