@scriptc/compiler 0.4.5 → 0.4.6

package/dist/frontend/program.js

@@ -38,6 +38,7 @@
  *    (jsoncSyntaxError) and fails preflight like 5.9.3 does — with
  *    JSON.parse's wording rather than tsc's, the one message-text delta on
  *    that path (no snapshot pins it). */
+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";
@@ -49,20 +50,22 @@ import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.
 import { npmStaticTypeExportPlan } from "./npm-static-type-exports-host.js";
 import { isNpmStaticSubclassArgument } from "./npm-static-subtyping.js";
 import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties, } from "./npm-static-declaration-syntax.js";
-import { configurePackageShims, isPackageShimFile, isShimmedImport, npmStaticOmitsPackage, } from "./package-shims.js";
+import { configurePackageShims, isPackageShimFile, isShimmedImport, isUnloadedPackage, npmStaticOmitsPackage, } from "./package-shims.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
 import { cjsLexedExportsOfFile, cjsVisibleNames } from "./cjs-syntax.js";
-import { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath, tsgoPath, } from "./dts-paths.js";
+import { 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, registerWorkspacePackage, workspacePackageOfPath, } from "./workspace-registry.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 { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
 import { forkTargetPaths } from "./fork-target.js";
 import { workerTargetPaths } from "./worker-target.js";
 import { erasedTypeOnlyImport, typeOnlyNamedImport, typeOnlyReachedFiles, } from "./type-only-imports.js";
 import { moduleSourceCandidates } from "./module-source-candidates.js";
-import { planDeclProjection } from "./decl-projection.js";
-import { reportShapes } from "./shape-inference/index.js";
+import { planDeclProjection, resetDeclBoundaryOrigins, } from "./decl-projection.js";
+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 { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
 import { containsJsx, firstJsx, jsxEmitName, jsxEmitPlan, jsxPragmas, lowerJsx, } from "./jsx-source.js";
 const BASE_OPTIONS = {
@@ -292,7 +295,7 @@ function visitNpmStaticDeclarationClosure(services, entryPath, onSource) {
         if (seen.has(path))
             return;
         seen.add(path);
-        const source = trackedReadFile(path);
+        const source = packageSourceText(path);
         if (source === null)
             return;
         onSource(path, source);
@@ -404,6 +407,28 @@ function externalTypeFileClosure7(program, externalTypes) {
     }
     return new Map([...ownersByFile].map(([file, owners]) => [file, [...owners]]));
 }
+/** The fallback declaration files of the Node modules the program's files
+ * name (fallbackModulesNamedIn) that the program does not hold yet. Each
+ * file is read as tsgo reads it; the TypeScript libraries and scriptc's own
+ * declarations name no module that needs a file. */
+function fallbackModuleRoots7(program, host) {
+    const names = program.getSourceFileNames();
+    const held = new Set(names.filter(isFallbackDtsPath).map((name) => tsgoPath(name)));
+    const ambient = ambientDtsPath();
+    const overrides = overridesDtsPath();
+    const roots = new Set();
+    for (const name of names) {
+        const path = tsgoPath(name);
+        if (held.has(path) || path === ambient || path === overrides)
+            continue;
+        if (/\/lib\.[^/]*\.d\.ts$/.test(path) && program.getSourceFileMetadata(name)?.isDefaultLibrary)
+            continue;
+        for (const file of fallbackModulesNamedIn(host.sourceText(name) ?? ""))
+            if (!held.has(file))
+                roots.add(file);
+    }
+    return [...roots];
+}
 /** 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
@@ -456,6 +481,13 @@ function createRequireProgramRoots7(program) {
     }
     return [...roots].sort();
 }
+/** Whether the tsc gate can keep a file's diagnostics when the program
+ * loads: it drops all of an opted-in package's files and of the package
+ * shims (keptErrors in preflight also drops unselected package JavaScript,
+ * which is not known yet here, so those files are still checked). */
+function tscGateFileKept(fileName) {
+    return npmStaticPackageOfPath(fileName) === null && !isPackageShimFile(fileName);
+}
 /** Classify the explicitly selected installed package's own sources. */
 export function entryPackageFilePredicate(entryPath) {
     const entryFile = tsgoPath(entryPath);
@@ -603,7 +635,10 @@ function loadProgram7(host, entryPath, externalTypes = new Map(),
 rootNpmStaticEdges = false, 
 /** The declaration-typed boundary's projection (decl-projection.ts):
  * answers rewritten user files for the lowering world, or null. */
-projector) {
+projector, 
+/** Shape inference's typed overlay (shape-inference/overlay.ts):
+ * rewritten package JavaScript for the lowering world, or null. */
+overlayer) {
     const config = adoptProjectConfig7(host, entryPath);
     const configuredPaths = config.options["paths"];
     setProjectPathMappings(configuredPaths !== undefined && typeof configuredPaths === "object" && configuredPaths !== null
@@ -643,12 +678,23 @@ projector) {
         }
         options = { ...options, paths };
     }
-    const coreRoots = [entryPath, ambientDtsPath(), nodeTypes ?? fallbackDtsPath()];
+    // Without @types/node the fallback declarations stand in: the core file,
+    // and a Node module's file once a program file names the module
+    // (fallbackModuleRoots7). The modules the entry names join the first
+    // program.
+    const coreRoots = [
+        entryPath,
+        ambientDtsPath(),
+        ...(nodeTypes === null
+            ? [fallbackDtsPath(), ...fallbackModulesNamedIn(host.sourceText(entryPath) ?? "")]
+            : [nodeTypes]),
+    ];
     const programRoots = [...coreRoots];
     let program = host.createProgram([...programRoots, overridesDtsPath()], options);
     try {
         for (let pass = 0; pass < 32; pass++) {
             const candidates = [
+                ...(nodeTypes === null ? fallbackModuleRoots7(program, host) : []),
                 ...entryPackageProgramRoots7(program, entryPath, rootNpmStaticEdges),
                 ...createRequireProgramRoots7(program),
                 ...forkTargetPaths(program, program.getImplementationSourceFiles()),
@@ -689,7 +735,7 @@ projector) {
             const original = program;
             // The project world must read the original text too, so it is built
             // before the rewritten files are served, and only when it is needed.
-            const diagnostics = ts.getPreEmitDiagnostics(original);
+            const diagnostics = ts.getPreEmitDiagnostics(original, tscGateFileKept);
             const errors = diagnostics.some((d) => d.category === ts.DiagnosticCategory.Error);
             tscWorld = {
                 program: original,
@@ -744,13 +790,55 @@ projector) {
                 else {
                     tscWorld = {
                         program: original,
-                        diagnostics: ts.getPreEmitDiagnostics(original),
+                        diagnostics: ts.getPreEmitDiagnostics(original, tscGateFileKept),
                         projectWorld: null,
                         declWorldFallback: true,
                     };
                 }
             }
         }
+        // Shape inference's overlay: package files typed from proven facts. The
+        // tsc gate keeps reading the files as written. loadProgram resets the
+        // overlay registry before the lowering world's load.
+        const overlayOriginals = new Map();
+        if (overlayer !== undefined && jsx.refusal === null) {
+            // Rounds: structural rewrites, then the typed overlay of the rebuilt
+            // program (shape-inference/index.ts).
+            const timeShapes = process.env["SCRIPTC_DEBUG_SHAPE_TIME"] !== undefined;
+            for (let round = 0; round < 3; round++) {
+                const t0 = timeShapes ? performance.now() : 0;
+                const overlay = overlayer(program, round);
+                if (timeShapes)
+                    process.stderr.write(`[shape-time] round ${round} overlayer ${(performance.now() - t0).toFixed(0)} ms\n`);
+                if (overlay === null || overlay.size === 0)
+                    break;
+                const t1 = timeShapes ? performance.now() : 0;
+                const before = program;
+                // The tsc gate reads the files as written: its diagnostics are
+                // taken before the overlay's files replace them on the host, and
+                // its project world (load.projectWorld()) is built over the files
+                // as written.
+                if (tscWorld === undefined)
+                    tscWorld = {
+                        program: before,
+                        diagnostics: ts.getPreEmitDiagnostics(before),
+                        projectWorld: null,
+                        declWorldFallback: true,
+                    };
+                for (const file of overlay.keys())
+                    if (!overlayOriginals.has(file))
+                        overlayOriginals.set(file, before.getSourceFile(file)?.text ?? null);
+                for (const [file, text] of overlay)
+                    host.addVirtualFile(file, text);
+                program = host.createProgram([...programRoots, overridesDtsPath()], options);
+                if (tscWorld.program !== before)
+                    before.dispose();
+                if (timeShapes)
+                    process.stderr.write(`[shape-time] round ${round} gate+program ${(performance.now() - t1).toFixed(0)} ms\n`);
+                if (shapeOverlayDone())
+                    break;
+            }
+        }
         const entry = program.getSourceFile(entryPath);
         if (!entry)
             throw new Error(`could not load ${entryPath}`);
@@ -759,6 +847,7 @@ projector) {
         return {
             program,
             entry,
+            shapeOverlayState: captureShapeOverlayState(),
             moduleOrder: [],
             configDiags: config.diags,
             ...(declBoundaryNotes.length > 0 ? { declBoundaryNotes } : {}),
@@ -772,7 +861,7 @@ projector) {
             externalTypeSpecifiersByFile,
             ...(tscWorld === undefined ? {} : { jsxSources: jsx.sources }),
             ...(tscWorld === undefined ? {} : { tscWorld }),
-            projectWorld: () => (projectWorld ??= host.createProgram(programRoots, options)),
+            projectWorld: () => (projectWorld ??= withFilesAsWritten(host, overlayOriginals, () => host.createProgram(programRoots, options))),
             disposeAll: () => {
                 try {
                     projectWorld?.dispose();
@@ -790,6 +879,27 @@ projector) {
         throw error;
     }
 }
+/** Runs `build` with the overlay's files served as written (their original
+ * texts), then serves the overlay's texts again. */
+function withFilesAsWritten(host, originals, build) {
+    if (originals.size === 0)
+        return build();
+    const overlaid = new Map();
+    for (const [file, text] of originals) {
+        const current = host.virtualFileText(file);
+        if (current !== undefined)
+            overlaid.set(file, current);
+        if (text !== null)
+            host.addVirtualFile(file, text);
+    }
+    try {
+        return build();
+    }
+    finally {
+        for (const [file, text] of overlaid)
+            host.addVirtualFile(file, text);
+    }
+}
 export function loadProgram(entryPath, services, opts) {
     entryPath = resolve(entryPath);
     const externalTypeEntries = opts?.externalTypes ?? [];
@@ -812,6 +922,11 @@ export function loadProgram(entryPath, services, opts) {
     // JavaScript, even when named. A registry entry's `sourceVersions`
     // (chalk 6) compile from their own source.
     configurePackageShims(entryPath);
+    resetDeclBoundaryOrigins();
+    resetDeclOriginVersions();
+    // The project's type patches (type-patches/layer.ts), read by every host
+    // this load creates; nothing at all without `scriptc.typePatches`.
+    configureTypePatches(entryPath, (path, text, kind) => services.parse(path, text, kind));
     const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])].filter((name) => !npmStaticOmitsPackage(entryPath, name));
     // Resolve authored declaration entries before enabling the JS-only
     // package resolver. Safe overload metadata binds through the runtime
@@ -974,7 +1089,13 @@ export function loadProgram(entryPath, services, opts) {
             return projection;
         };
     try {
-        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0, projector);
+        // The overlay registry is per process and describes the lowering
+        // world's load: a load without the overlay must not see an earlier
+        // load's overlay files. The authored world (authored()) is a second load
+        // 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);
         // 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)
@@ -1045,11 +1166,12 @@ 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 } = preflight7(load);
+    const { diags, moduleOrder, startupCrash, inlineRequireCycleCalls, moduleEdges, dynamicImportRejections, } = preflight7(load);
     load.moduleOrder = moduleOrder;
     load.startupCrash = startupCrash;
     load.inlineRequireCycleCalls = inlineRequireCycleCalls;
     load.moduleEdges = moduleEdges;
+    load.dynamicImportRejections = dynamicImportRejections;
     return diags;
 }
 /* Finding 5: tsgo's strict CommonJS modeling fires checker codes on JS
@@ -2209,21 +2331,32 @@ export function isCreateRequireBinding7(program, callee) {
 /** How a use of a createRequire loader lowers:
  * - "static": a literal call or a literal resolution query, which erases
  *   the loader value.
- * - "deferred": a call with a computed specifier or another argument shape,
- *   or `resolve` / `resolve.paths` read as a value, inside the try block
- *   of a try statement in the same function. The call throws a runtime
- *   fence, and the resolve value is a function that throws one when called
- *   (module-resolution.ts), so the statement's catch clause handles them
- *   (packages that look for optional native addons).
- * - "computed": the same shapes outside a try block.
+ * - "runtime": in JavaScript source, a call with a computed specifier, a
+ *   require.resolve call with a computed request, or `resolve` read as a
+ *   value. The runtime resolves the specifier like Node
+ *   (module-resolution.ts, scr_require.c).
+ * - "deferred": in JavaScript source, inside the try block of a try
+ *   statement in the same function, the other shapes: spread arguments,
+ *   require.resolve with another argument count, and `resolve.paths` with
+ *   a computed request or read as a value. The call throws a runtime
+ *   fence, and the resolve.paths value is a function that throws one when
+ *   called (module-resolution.ts), so the statement's catch clause handles
+ *   them (packages that look for optional native addons).
+ * - "computed": the "runtime" uses in TypeScript source, and the
+ *   "deferred" shapes outside a try block.
  * - "escaping": the loader itself as a value, writes, optional calls, and
  *   other members. */
-const COMPUTED_CREATE_REQUIRE_REASON = "its createRequire result is used with a computed specifier, or its resolve as a value, outside a try block (static requires need literal specifiers)";
+const COMPUTED_CREATE_REQUIRE_REASON = "its createRequire result is used with a computed specifier in TypeScript, or with spread arguments or resolve.paths outside a try block (static requires need literal specifiers)";
 function createRequireUse7(expr) {
+    const use = createRequireUseShape7(expr);
+    return use === "runtime" && !isJsSourceFile(ts.getSourceFileOfNode(expr)) ? "computed" : use;
+}
+function createRequireUseShape7(expr) {
     let use = expr;
     while (ts.isParenthesizedExpression(use.parent))
         use = use.parent;
     let member = false;
+    let paths = false;
     if (ts.isPropertyAccessExpression(use.parent) &&
         use.parent.expression === use &&
         use.parent.name.text === "resolve" &&
@@ -2233,19 +2366,29 @@ function createRequireUse7(expr) {
         if (ts.isPropertyAccessExpression(use.parent) &&
             use.parent.expression === use &&
             use.parent.name.text === "paths" &&
-            !use.parent.questionDotToken)
+            !use.parent.questionDotToken) {
             use = use.parent;
+            paths = true;
+        }
     }
     const call = use.parent;
     if (ts.isCallExpression(call) && call.expression === use) {
         if (call.questionDotToken)
             return "escaping";
-        if (call.arguments.nodes.length === 1 && ts.isStringLiteralLike(call.arguments.nodes[0]))
+        const args = call.arguments.nodes;
+        if (args.length === 1 && ts.isStringLiteralLike(args[0]))
             return "static";
+        if (!paths &&
+            !args.some((arg) => ts.isSpreadElement(arg)) &&
+            !(member && (args.length === 0 || args.length > 2)))
+            return "runtime";
     }
     else if (!member || isAssignmentTarget7(use)) {
         return "escaping";
     }
+    else if (!paths) {
+        return "runtime";
+    }
     return insideTryBlock7(use) ? "deferred" : "computed";
 }
 function isAssignmentTarget7(node) {
@@ -4567,7 +4710,7 @@ function laterJobCallee7(checker, callee) {
     // package declarations describe user code.
     return decls.every((d) => {
         const file = ts.getSourceFileOfNode(d).fileName;
-        return isNodeTypesPath(file) || file === fallbackDtsPath();
+        return isNodeTypesPath(file) || isFallbackDtsPath(file);
     });
 }
 /** Standard-library functions whose callbacks run as later jobs. */
@@ -4963,7 +5106,12 @@ function preflight7(load) {
         const sf = p.getSourceFile(d.fileName);
         return sf !== undefined && isCheckedJsSourceFile(sf, projectCheckJs);
     };
-    const errorsOf = (p) => keptErrors(p, ts.getPreEmitDiagnostics(p));
+    // 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.
@@ -5216,6 +5364,14 @@ function preflight7(load) {
                     diags.push(unsupportedDiag("SC1014", locOf7(stmt), "re-exports from packages or builtin modules"));
                     continue;
                 }
+                // A re-export from a Node island package that tsconfig `paths` maps
+                // to its installed directory: its declarations are no program
+                // module (the lowering reports the island boundary).
+                if (projectReexport !== null &&
+                    projectReexport.isDeclarationFile &&
+                    !isRelativeSpecifier(fromSpec) &&
+                    isFrontendIsland(packageNameOfSpecifier(fromSpec)))
+                    continue;
                 const reDep = projectReexport;
                 // `export * as ns from "./m"` re-exports the module NAMESPACE
                 // object under a name: importers' `x.ns.member` reads resolve
@@ -5274,9 +5430,9 @@ function preflight7(load) {
             // refused edge never link, so every clause fence below is skipped —
             // their uses meet the lowering's own fences if the code demands
             // values from them.
-            const refuse = (message, className, fallbackFeature) => {
+            const refuse = (message, className, fallbackFeature, code) => {
                 refusals.get(sf).push({
-                    crash: { message, className, loc: locOf7(stmt) },
+                    crash: { message, className, loc: locOf7(stmt), ...(code !== undefined ? { code } : {}) },
                     fallback: unsupportedDiag("SC1010", locOf7(stmt), fallbackFeature),
                     pos: ts.tokenStartOfNode(stmt),
                 });
@@ -5315,7 +5471,7 @@ function preflight7(load) {
                     // most commonly): that program is Node's startup crash, not an
                     const refusal = probeNodeImportRefusal(sf.fileName, spec);
                     if (refusal !== null) {
-                        refuse(refusal.message, "%Error", `the '${spec}' package (its runtime resolution fails: ${refusal.message})`);
+                        refuse(refusal.message, "%Error", `the '${spec}' package (its runtime resolution fails: ${refusal.message})`, refusal.code);
                     }
                     continue;
                 }
@@ -5327,6 +5483,14 @@ function preflight7(load) {
             // Node's startup crash with Node's exact message; what keeps a compile
             // fence is unsupported builtin or types-only surface.
             if (isBare && npmStaticDep === null) {
+                // A Node island package that tsconfig `paths` maps to its
+                // installed directory resolves to its declarations here: it loads
+                // in Node, typed by them, like an island package resolved through
+                // node_modules (scope-B NI-4).
+                if (projDep !== null &&
+                    projDep.isDeclarationFile &&
+                    isFrontendIsland(packageNameOfSpecifier(spec)))
+                    continue;
                 if (projDep !== null && projDep.isDeclarationFile) {
                     diags.push(unsupportedDiag("SC1010", locOf7(stmt), `the '${spec}' import (it resolves only to type declarations — there is no runtime implementation to compile)`));
                     continue;
@@ -5343,7 +5507,7 @@ function preflight7(load) {
                         continue;
                     }
                     if (spec === "#") {
-                        refuse(`Invalid module "#" is not a valid internal imports specifier name imported from ${sf.fileName}`, "%TypeError", `the '#' import (Node rejects the bare '#' specifier as invalid)`);
+                        refuse(`Invalid module "#" is not a valid internal imports specifier name imported from ${sf.fileName}`, "%TypeError", `the '#' import (Node rejects the bare '#' specifier as invalid)`, "ERR_INVALID_MODULE_SPECIFIER");
                         continue;
                     }
                     if (spec.startsWith("#")) {
@@ -5353,7 +5517,7 @@ function preflight7(load) {
                             continue;
                         }
                         const pkgJson = nearestPkgJsonPath(sf.fileName);
-                        refuse(`Package import specifier "${spec}" is not defined${pkgJson !== null ? ` in package ${pkgJson}` : ""} imported from ${sf.fileName}`, "%TypeError", `the '${spec}' import (no package.json imports-field entry maps it)`);
+                        refuse(`Package import specifier "${spec}" is not defined${pkgJson !== null ? ` in package ${pkgJson}` : ""} imported from ${sf.fileName}`, "%TypeError", `the '${spec}' import (no package.json imports-field entry maps it)`, "ERR_PACKAGE_IMPORT_NOT_DEFINED");
                         continue;
                     }
                     const refusal = probeNodeImportRefusal(sf.fileName, spec);
@@ -5361,7 +5525,7 @@ function preflight7(load) {
                         const ambientNote = ambientDeclared(spec)
                             ? `the '${spec}' module (it exists only as an ambient 'declare module' type surface — there is no runtime module to import)`
                             : `the '${spec}' package (nothing installed resolves it)`;
-                        refuse(refusal.message, "%Error", ambientNote);
+                        refuse(refusal.message, "%Error", ambientNote, refusal.code);
                         continue;
                     }
                     // Runtime-resolvable (or a shape the probe stays conservative
@@ -5441,7 +5605,10 @@ function preflight7(load) {
                             diags.push(unsupportedDiag("SC1013", locOf7(clause.namedBindings), "namespace imports of CommonJS modules"));
                         }
                     }
-                    else if (dep === null && !(!isRelative && ambientModules.has(spec))) {
+                    else if (dep === null &&
+                        !(!isRelative && ambientModules.has(spec)) &&
+                        // A Node island module's namespace (scope-B NI-4).
+                        !(!isRelative && isFrontendIsland(packageNameOfSpecifier(spec)))) {
                         diags.push(unsupportedDiag("SC1013", locOf7(clause.namedBindings)));
                     }
                 }
@@ -5597,7 +5764,9 @@ function preflight7(load) {
                                 // optional-dependency try/require pattern), so no fence.
                                 // Binding forms keep the fence: their downstream reads
                                 // would need the module that never loads.
-                                if (req.decl !== null || probeNodeRequireRefusal(sf.fileName, req.spec) === null) {
+                                if ((req.decl !== null || probeNodeRequireRefusal(sf.fileName, req.spec) === null) &&
+                                    // A Node island package: loaded in Node at the require (NI-4).
+                                    !isFrontendIsland(packageNameOfSpecifier(req.spec))) {
                                     diags.push(unsupportedDiag("SC1010", loc, unsupportedModuleFeatureOf(req.spec)));
                                 }
                             }
@@ -5657,7 +5826,8 @@ function preflight7(load) {
                     if (canonicalBuiltinModule(spec) === null && !processModuleAliasRequire7(spec, null)) {
                         // Binding-less by construction — same require-site throw
                         // channel as the statement-level form above.
-                        if (probeNodeRequireRefusal(sf.fileName, spec) === null) {
+                        if (probeNodeRequireRefusal(sf.fileName, spec) === null &&
+                            !isFrontendIsland(packageNameOfSpecifier(spec))) {
                             diags.push(unsupportedDiag("SC1010", loc, unsupportedModuleFeatureOf(spec)));
                         }
                     }
@@ -5782,6 +5952,7 @@ function preflight7(load) {
     // them). A found resolution crash wins over the CJS link check below:
     // Node's fetch/resolve phase runs before instantiate.
     let resolveCrash = null;
+    const dynamicImportRejections = new Map();
     {
         const seen = new Set();
         const walk = (sf) => {
@@ -5804,6 +5975,52 @@ function preflight7(load) {
             return null;
         };
         resolveCrash = walk(entry);
+        // A module only a literal import() loads resolves its static graph when
+        // that import runs: Node rejects the import's promise with the first
+        // refusal it meets, before any module of that graph evaluates. Such a
+        // module never joins the compiled graph, and the refusals inside its
+        // graph are that rejection, not build failures.
+        const reach = (from, into) => {
+            const stack = [from];
+            while (stack.length > 0) {
+                const sf = stack.pop();
+                if (into.has(sf))
+                    continue;
+                into.add(sf);
+                for (const { dep } of depPositions.get(sf) ?? [])
+                    stack.push(dep);
+            }
+        };
+        const startup = new Set();
+        reach(entry, startup);
+        const covered = new Set();
+        for (const sf of userFiles) {
+            if (!sf.text.includes("import"))
+                continue;
+            for (const call of moduleSourceCandidates(program, sf).calls) {
+                const arg = call.arguments.nodes[0];
+                if (call.expression.kind !== ts.SyntaxKind.ImportKeyword || arg === undefined)
+                    continue;
+                if (!ts.isStringLiteralLike(arg) || isUnloadedPackage(arg.text))
+                    continue;
+                const root = resolveImport7(program, sf, arg.text) ?? npmStaticDepSf7(program, sf, arg.text);
+                if (root === null || root.isDeclarationFile || startup.has(root))
+                    continue;
+                // A module inside an already-rejected graph is `covered`, but a
+                // literal import() of it needs its OWN rejection entry: its graph
+                // rejects when that import runs, so it must not join the compiled
+                // graph (where lowering would fail) merely because another rejected
+                // import also reaches it. Walk each direct root independently.
+                if (dynamicImportRejections.has(root))
+                    continue;
+                seen.clear();
+                const crash = walk(root);
+                if (crash === null)
+                    continue;
+                dynamicImportRejections.set(root, crash);
+                reach(root, covered);
+            }
+        }
         // The crash channel engages only for programs that OTHERWISE pass
         // preflight: when any other diagnostic already fails the build, every
         // refusal keeps its compile-fence fallback instead — the report names
@@ -5811,7 +6028,9 @@ function preflight7(load) {
         // get a diagnostic. (No reachable refusal → same: fallbacks only.)
         if (resolveCrash === null || diags.length > 0) {
             resolveCrash = null;
-            for (const cands of refusals.values()) {
+            for (const [sf, cands] of refusals) {
+                if (covered.has(sf) && !startup.has(sf))
+                    continue;
                 for (const c of cands)
                     diags.push(c.fallback);
             }
@@ -5826,6 +6045,7 @@ function preflight7(load) {
         startupCrash: resolveCrash ?? linkCrash,
         inlineRequireCycleCalls,
         moduleEdges: edges,
+        dynamicImportRejections,
     };
 }
 /* ── the CJS named-import link check ─────────────────────────────────────
@@ -6419,7 +6639,7 @@ const nodeBuiltinNames = new Set(builtinModules);
  * resolution, locations), exported under the names the 5.9.3 program.ts
  * established (the phase-2 port kept every spelling); the world-neutral
  * helpers re-export from their focused modules. */
-export { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath } from "./dts-paths.js";
+export { 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, };