ttsc 0.24.0 → 0.25.0

package/lib/launcher/internal/runtimeHooks.js

@@ -8,12 +8,14 @@ exports.checkNodeRuntimeSupport = checkNodeRuntimeSupport;
 exports.installRuntimeHooks = installRuntimeHooks;
 exports.entryModuleFormat = entryModuleFormat;
 exports.restoreStrippedNodeBuiltinScheme = restoreStrippedNodeBuiltinScheme;
+exports.projectModuleOptions = projectModuleOptions;
 exports.isWithin = isWithin;
 exports.readDependencyCache = readDependencyCache;
 exports.acquireDependencyBuildLock = acquireDependencyBuildLock;
 exports.releaseDependencyBuildLock = releaseDependencyBuildLock;
 exports.reclaimDependencyBuildLock = reclaimDependencyBuildLock;
 exports.inspectDependencyBuildLock = inspectDependencyBuildLock;
+exports.realPath = realPath;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_module_1 = require("node:module");
@@ -197,12 +199,13 @@ function installCommonJsHook() {
 }
 /**
  * The module format of the entry source file, derived from the entry project's
- * `module` option (via the runtime manifest) the same way the served files are
+ * compiler options (via the runtime manifest) the same way the served files are
  * classified. The bootstrap uses it to load the entry through a CommonJS
  * `require` or an ESM `import`.
  */
 function entryModuleFormat(entryFile) {
-    return moduleFormat(entryFile, manifest()?.moduleOption) === "module"
+    const m = manifest();
+    return moduleFormat(entryFile, m === null ? null : (m.moduleOptions ?? {})) === "module"
         ? "module"
         : "commonjs";
 }
@@ -261,7 +264,7 @@ function load(url, context, nextLoad) {
 }
 function resolveRuntimeSource(filename, url = (0, node_url_1.pathToFileURL)(filename).href) {
     const served = resolveServedSource(filename, url);
-    const format = moduleFormat(filename, served.moduleOption);
+    const format = moduleFormat(filename, served.moduleOptions);
     return {
         format,
         source: format === "commonjs" && commonJsNamedInteropUrls.has(url)
@@ -275,6 +278,17 @@ function rememberCommonJsNamedInterop(result, context) {
     }
     return result;
 }
+/**
+ * Whether a CommonJS-classified TypeScript source reached from an ESM parent
+ * needs its nested `export *` names exposed.
+ *
+ * Only the parent side is decided here. The child's own format is re-checked
+ * authoritatively in `resolveRuntimeSource` against the format its served
+ * source actually carries, so this predicate deliberately does not repeat that
+ * check: doing so would need the child's owning project, which is not known
+ * until the source is served, and an answer guessed from the nearest tsconfig
+ * silently under-exposes a file that tsconfig does not compile.
+ */
 function shouldExposeCommonJsNamedExports(url, parentURL) {
     if (parentURL === undefined ||
         !url.startsWith("file:") ||
@@ -282,45 +296,67 @@ function shouldExposeCommonJsNamedExports(url, parentURL) {
         return false;
     }
     const parentFile = (0, node_url_1.fileURLToPath)(parentURL);
-    if (moduleFormat(parentFile, moduleOptionForSource(parentFile)) !== "module") {
+    if (moduleFormat(parentFile, owningModuleOptions(parentFile)) !== "module") {
         return false;
     }
-    const filename = (0, node_url_1.fileURLToPath)(url);
-    return (isTypeScriptSource(filename) &&
-        moduleFormat(filename, moduleOptionForSource(filename)) === "commonjs");
+    return isTypeScriptSource((0, node_url_1.fileURLToPath)(url));
 }
-function moduleOptionForSource(filename) {
+/**
+ * The emit-deciding compiler options of the project that owns `filename`, or
+ * `null` when none does.
+ *
+ * The entry project owns a file only when it actually emitted it. Testing
+ * `isWithin(rootDir)` alone would claim every file under a wide `rootDir` —
+ * including the volume-root `rootDir` a config-loader project uses — and hand
+ * them the entry project's options even though the dependency or orphan lane is
+ * what serves them.
+ */
+function owningModuleOptions(filename) {
     if (!isTypeScriptSource(filename)) {
-        return undefined;
+        return null;
     }
     const real = realPath(filename);
     const m = manifest();
-    if (m !== null && isWithin(real, m.rootDir)) {
-        return m.moduleOption;
+    if (m !== null && entryEmitPath(m, real) !== null) {
+        return m.moduleOptions ?? {};
     }
     const tsconfig = nearestTsconfig(real);
     if (tsconfig === null) {
-        return undefined;
+        return null;
     }
-    if (moduleOptionCache.has(tsconfig)) {
-        return moduleOptionCache.get(tsconfig);
+    const cached = moduleOptionsCache.get(tsconfig);
+    if (cached !== undefined) {
+        return cached;
     }
-    let moduleOption;
+    let options = {};
     try {
         const project = (0, readProjectConfig_1.readProjectConfig)({
             cwd: node_path_1.default.dirname(tsconfig),
             tsconfig,
         });
-        moduleOption =
-            typeof project.compilerOptions.module === "string"
-                ? project.compilerOptions.module
-                : undefined;
+        options = projectModuleOptions(project.compilerOptions);
     }
     catch {
-        moduleOption = undefined;
+        // The owning project cannot be read, so nothing is known about the format
+        // it would have emitted. That is the same state as having no project at
+        // all, and it is what the dependency lane will conclude too when its build
+        // fails and the file falls through to the orphan type-strip.
+        moduleOptionsCache.set(tsconfig, null);
+        return null;
     }
-    moduleOptionCache.set(tsconfig, moduleOption);
-    return moduleOption;
+    moduleOptionsCache.set(tsconfig, options);
+    return options;
+}
+/** Narrow a resolved project's compiler options to the emit-format pair. */
+function projectModuleOptions(compilerOptions) {
+    return {
+        ...(typeof compilerOptions.module === "string"
+            ? { module: compilerOptions.module }
+            : {}),
+        ...(typeof compilerOptions.target === "string"
+            ? { target: compilerOptions.target }
+            : {}),
+    };
 }
 /**
  * Resolve the JavaScript to run for a TypeScript source file, in priority
@@ -333,17 +369,14 @@ function resolveServedSource(filename, url = (0, node_url_1.pathToFileURL)(filen
     const real = realPath(filename);
     const served = serveEntryEmit(real);
     if (served !== null) {
-        return withInlineSourceMap({
-            moduleOption: manifest()?.moduleOption,
-            ...served,
-        });
+        return withInlineSourceMap(served);
     }
     const built = serveDependencyEmit(real);
     if (built !== null) {
         return withInlineSourceMap(built);
     }
     return {
-        moduleOption: undefined,
+        moduleOptions: null,
         sourceFile: filename,
         source: transformOrphanSource(filename, url),
     };
@@ -376,7 +409,7 @@ function withInlineSourceMap(served) {
  * owning project; an ESM-format orphan keeps the fast in-process strip.
  */
 function transformOrphanSource(filename, url) {
-    if (moduleFormat(filename, undefined) === "commonjs") {
+    if (moduleFormat(filename, null) === "commonjs") {
         const lowered = emitOrphanAsCommonJs(filename);
         if (lowered !== null) {
             return lowered;
@@ -908,23 +941,49 @@ function serveEntryEmit(real) {
     if (m === null) {
         return null;
     }
-    if (!isWithin(real, m.rootDir)) {
-        return null;
-    }
-    const emitted = (0, resolveEmittedJavaScript_1.resolveEmittedJavaScript)({
-        emittedFiles: m.emittedFiles,
-        outDir: m.emitDir,
-        projectRoot: m.rootDir,
-        sourceFile: real,
-    });
+    const emitted = entryEmitPath(m, real);
     if (emitted === null) {
         return null;
     }
     const source = readFileOrNull(emitted);
     return source === null
         ? null
-        : { emittedFile: emitted, source, sourceFile: real };
+        : {
+            emittedFile: emitted,
+            moduleOptions: m.moduleOptions ?? {},
+            source,
+            sourceFile: real,
+        };
+}
+/**
+ * The entry project's emitted JavaScript for `real`, or `null` when that
+ * project did not emit it. Shared with `owningModuleOptions` so "the entry
+ * project owns this file" means exactly one thing in both places.
+ */
+function entryEmitPath(m, real) {
+    const cached = entryEmitPathCache.get(real);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const resolved = isWithin(real, m.rootDir)
+        ? (0, resolveEmittedJavaScript_1.resolveEmittedJavaScript)({
+            emittedFiles: m.emittedFiles,
+            outDir: m.emitDir,
+            projectRoot: m.rootDir,
+            sourceFile: real,
+        })
+        : null;
+    entryEmitPathCache.set(real, resolved);
+    return resolved;
 }
+/**
+ * Memo for `entryEmitPath`, because it is now on the `resolve` hook's path
+ * through `owningModuleOptions` — once per import specifier — and a miss inside
+ * `resolveEmittedJavaScript` walks the whole emit tree. The entry emit is
+ * written once before the run starts and never changes under it, so one answer
+ * per path is the only one there is.
+ */
+const entryEmitPathCache = new Map();
 /**
  * True when `real` is `directory` itself or sits beneath it. Handles a root
  * `directory` (`/`, `C:\`): naively appending a separator would yield `//`,
@@ -982,7 +1041,7 @@ function serveBuiltDependency(built, real) {
         ? null
         : {
             emittedFile: emitted,
-            moduleOption: built.moduleOption,
+            moduleOptions: built.moduleOptions,
             source,
             sourceFile: real,
         };
@@ -1063,7 +1122,15 @@ function readDependencyCache(cacheDir, metaPath) {
         return null;
     }
     if (!isDependencyGeneration(meta.generation) ||
-        typeof meta.rootDir !== "string") {
+        typeof meta.rootDir !== "string" ||
+        // A marker with no `moduleOptions` object predates this field and cannot
+        // say which format its emit carries. Treating the absence as "no options"
+        // would classify a CommonJS emit as an ES module, so the generation is
+        // rejected and rebuilt instead. Every marker this version writes carries
+        // the object, empty or not.
+        typeof meta.moduleOptions !== "object" ||
+        meta.moduleOptions === null ||
+        Array.isArray(meta.moduleOptions)) {
         return null;
     }
     const emitDir = dependencyGenerationDir(cacheDir, meta.generation);
@@ -1073,8 +1140,16 @@ function readDependencyCache(cacheDir, metaPath) {
     return {
         emitDir,
         emittedFiles: undefined,
-        moduleOption: typeof meta.moduleOption === "string" ? meta.moduleOption : undefined,
-        rootDir: meta.rootDir,
+        moduleOptions: projectModuleOptions(meta.moduleOptions),
+        // Resolved on the way out, not trusted as written. `rootDir` never gated
+        // reuse — the marker's generation, module options, and a non-empty emit do
+        // — so a marker carrying an unresolved spelling was already being reused,
+        // and then served every file of that dependency through the whole-tree stem
+        // rescan. The pass is idempotent and runs only on a hit, which
+        // `ensureProjectBuilt` memoizes per tsconfig. A marker from an earlier ttsc
+        // survives only under the shared `os.tmpdir()/ttsx-dep` fallback root; the
+        // manifest's own `depCacheDir` is per-process and removed with the run.
+        rootDir: resolvePhysicalPath(meta.rootDir),
     };
 }
 /**
@@ -1194,14 +1269,10 @@ function buildDependency(tsconfig, cacheDir, metaPath) {
             .filter((line) => line.trim().length !== 0)
             .join("\n"));
     }
-    const rootDir = typeof project.compilerOptions.rootDir === "string"
-        ? project.compilerOptions.rootDir
-        : project.root;
-    const moduleOption = typeof project.compilerOptions.module === "string"
-        ? project.compilerOptions.module
-        : undefined;
-    publishDependencyMeta(metaPath, { generation, moduleOption, rootDir });
-    return { emitDir, emittedFiles: undefined, moduleOption, rootDir };
+    const rootDir = resolveDependencySourceRoot(project);
+    const moduleOptions = projectModuleOptions(project.compilerOptions);
+    publishDependencyMeta(metaPath, { generation, moduleOptions, rootDir });
+    return { emitDir, emittedFiles: undefined, moduleOptions, rootDir };
 }
 /**
  * Publish the completion marker atomically: write it to a private temp name in
@@ -1512,7 +1583,7 @@ function formatDuration(ms) {
 }
 /** Owning-tsconfig cache keyed by directory, mirroring `packageTypeCache`. */
 const tsconfigCache = new Map();
-const moduleOptionCache = new Map();
+const moduleOptionsCache = new Map();
 /**
  * The nearest `tsconfig.json` at or above `file`'s directory, or `null`. The
  * walk stops at a `node_modules` boundary: a tsconfig above `node_modules`
@@ -1565,14 +1636,81 @@ function readFileOrNull(file) {
         return null;
     }
 }
+/**
+ * The physical path, in the same spelling the launcher decided on.
+ *
+ * `realpathSync.native` first, because the plain implementation resolves
+ * reparse points but leaves a Windows 8.3 component alone — and `TEMP` is
+ * `C:\Users\RUNNER~1\...` on a GitHub Windows runner. The launcher resolves the
+ * entry through `fs.realpathSync.native`, so answering here with the short name
+ * would put a `..` in `path.relative(rootDir, real)`, drop the exact-mirror
+ * lane, and leave the entry to whatever the trailing-stem matcher picks.
+ */
 function realPath(target) {
     try {
-        return node_fs_1.default.realpathSync(target);
+        return node_fs_1.default.realpathSync.native?.(target) ?? node_fs_1.default.realpathSync(target);
     }
     catch {
         return target;
     }
 }
+/**
+ * The physical spelling of a path, produced the way the served sources it will
+ * be compared against are produced.
+ *
+ * `createFilesystemPathIdentityContext` is the same resolver the entry lane
+ * uses (`prepareExecution.ts::resolveRuntimeSourceRoot`). For a path that
+ * exists it is one `realpathSync.native`. For one that does not it resolves as
+ * far as the filesystem goes and folds the missing tail by the case semantics
+ * of the surviving ancestor, which costs a directory read and, on Windows, can
+ * cost an `fsutil` query — worth knowing, but off the path a real dependency
+ * root takes.
+ *
+ * Total on purpose. `throwOnRealpathError: false` silences a failed realpath,
+ * but the case-sensitivity probe can still fail on its own (an unreadable
+ * ancestor, a denied alternate-case `lstat`), and neither caller has anywhere
+ * to put that: `readDependencyCache` is contracted to answer `null` rather than
+ * throw, and `buildDependency` has already produced its emit. The unresolved
+ * spelling is exactly what both had before this pass, so it is the fallback.
+ */
+function resolvePhysicalPath(location) {
+    try {
+        return (0, projectInputPathIdentity_1.createFilesystemPathIdentityContext)({
+            throwOnRealpathError: false,
+        }).resolve(location).path;
+    }
+    catch {
+        return location;
+    }
+}
+/**
+ * The source-tree root a dependency's emit mirrors, in the spelling
+ * `resolveEmittedJavaScript` compares a served source against.
+ *
+ * Both branches need the pass, for different reasons. A declared `rootDir`
+ * arrives from `readProjectConfig` joined against the config that declared it
+ * but never resolved, so a `rootDir` that is itself a symlinked directory stays
+ * unresolved. `project.root` arrives through plain `fs.realpathSync`, which
+ * follows reparse points but leaves a Windows 8.3 component alone — and
+ * {@link realPath} uses `fs.realpathSync.native`, which expands it. Either way
+ * `path.relative` puts a `..` in front of an in-project source,
+ * `resolveExactEmittedFiles` returns nothing, and every served file of that
+ * dependency falls to the trailing-stem matcher, which rescans the whole emit
+ * tree per file because a dependency build publishes no emitted-file list.
+ *
+ * This is the pass the entry lane settled on for the same mixed pair; the two
+ * lanes now read alike, `path.isAbsolute` guard included. `readProjectConfig`
+ * absolutizes every path option against the config that declared it, so that
+ * guard is a mirror of the entry lane rather than a live branch.
+ */
+function resolveDependencySourceRoot(project) {
+    const rootDir = project.compilerOptions.rootDir;
+    return resolvePhysicalPath(typeof rootDir !== "string"
+        ? project.root
+        : node_path_1.default.isAbsolute(rootDir)
+            ? rootDir
+            : node_path_1.default.resolve(project.root, rootDir));
+}
 /**
  * Map the JavaScript extension a relative `specifier` carries to the TypeScript
  * source extensions tsgo would have emitted it from. Running from source, a
@@ -1654,35 +1792,138 @@ function probeRescuableSpecifier(specifier, parentURL) {
 }
 /**
  * Decide the module format the way Node and tsgo do — from configuration, never
- * by sniffing the emitted text. The file extension is authoritative
- * (`.mts`/`.mjs` → module, `.cts`/`.cjs` → commonjs); otherwise the owning
- * tsconfig's `module` option decides: a fixed CommonJS / ES target maps
- * directly, while the `node*`/`preserve` family (and a file with no owning
- * tsconfig) defers to the nearest `package.json` `type`, exactly as tsgo chose
- * when it emitted.
+ * by sniffing the emitted text.
+ *
+ * The file extension is authoritative first (`.mts`/`.mjs` → module,
+ * `.cts`/`.cjs` → commonjs), exactly as tsgo's
+ * `getImpliedNodeFormatForEmitWorker` checks it ahead of everything else.
+ *
+ * After that the decision belongs to the project that emitted the file, so
+ * `options` is the whole compiler-option pair tsgo consults, not just `module`:
+ * an absent `module` is NOT "ask Node", it is "derive the kind from `target`"
+ * (tsgo's `getEmitModuleKind`), and TypeScript 7 defaults `target` to the
+ * latest standard, which means ES modules. Only the `node*` family defers to
+ * the nearest `package.json` `type`, because only that family makes tsgo
+ * consult it.
+ *
+ * `options` is `null` for a file no tsconfig owns at all — a raw `.ts` shipped
+ * under `node_modules`. Nothing emitted it, so Node's own rule is the only rule
+ * there is, and the package `type` decides.
  */
-function moduleFormat(filename, moduleOption) {
+function moduleFormat(filename, options) {
     if (filename.endsWith(".mts") || filename.endsWith(".mjs")) {
         return "module";
     }
     if (filename.endsWith(".cts") || filename.endsWith(".cjs")) {
         return "commonjs";
     }
-    const option = (moduleOption ?? "").toLowerCase();
-    if (option === "commonjs" || option === "node10" || option === "none") {
-        return "commonjs";
+    if (options === null) {
+        return nearestPackageType(filename);
     }
-    if (option === "" ||
-        option === "node16" ||
-        option === "node18" ||
-        option === "nodenext" ||
-        option === "preserve") {
+    // A package that states its `type` outright decides for the files inside it
+    // whatever the module kind is. This is where a source-shipping dependency's
+    // own declaration overrides the compiling project's `module`; see
+    // `declaredNodeModulesPackageType` for why `node_modules` bounds it.
+    const declared = declaredNodeModulesPackageType(filename);
+    if (declared !== null) {
+        return declared;
+    }
+    const kind = effectiveModuleKind(options);
+    if (kind === "node16" ||
+        kind === "node18" ||
+        kind === "node20" ||
+        kind === "nodenext") {
         return nearestPackageType(filename);
     }
-    // Every remaining `module` target (es2015 … esnext, system, amd, umd) emits
-    // ECMAScript modules.
+    if (kind === "commonjs") {
+        return "commonjs";
+    }
+    // Everything that remains (es2015 … esnext, and `preserve`, which keeps the
+    // authored ESM syntax verbatim whatever the package `type` says) is emitted
+    // as ECMAScript modules. `amd`, `umd`, and `system` are not among them:
+    // TypeScript 7 removed all three, so a project declaring one cannot build,
+    // and a file it would have owned reaches the run through the orphan lane
+    // instead.
     return "module";
 }
+/**
+ * The `"type"` a `node_modules` package states for `filename`, or `null`.
+ *
+ * Tsgo's `GetImpliedNodeFormatForEmitWorker` consults a file's
+ * `packageJsonType` for **every** module kind, not just the `node*` family. So
+ * a source-shipping dependency that declares `"type": "commonjs"` is emitted as
+ * CommonJS even while the compiling project asks for `esnext`, and the mirror
+ * has to honour the same override or Node is handed the wrong format.
+ *
+ * Outside `node_modules` that field is empty for every module kind this
+ * override can change. `loadSourceFileMetaData` does fill it elsewhere — for a
+ * file whose extension does not itself state the format (anything but `.mts`,
+ * `.cts`, `.mjs`, `.cjs`) whose project sets `moduleResolution` to the
+ * `node16`…`nodenext` family — but `program.go` rejects that resolution unless
+ * `module` is in the same family, and for a `node*` `module` the package `type`
+ * is already the whole answer, which the caller's own `node*` branch produces.
+ * So answering from a manifest outside `node_modules` could only override the
+ * project's own `module` option, the very confusion this classifier exists to
+ * end.
+ */
+function declaredNodeModulesPackageType(filename) {
+    if (!pathHasNodeModulesSegment(filename)) {
+        return null;
+    }
+    return declaredPackageType(filename);
+}
+/**
+ * Whether any path segment of `filename` is literally `node_modules`.
+ *
+ * Case-sensitive on every platform, because the upstream test this mirrors is a
+ * case-sensitive substring search and Node's own resolver recognises only the
+ * exact spelling. A directory named `Node_Modules` is a package store to
+ * neither of them, and must not become one here.
+ */
+function pathHasNodeModulesSegment(filename) {
+    return filename.split(/[\\/]/).includes("node_modules");
+}
+/**
+ * The `module` kind tsgo actually emits with, mirroring `getEmitModuleKind`:
+ * the declared `module` when there is one, and otherwise the kind implied by
+ * `target`. `"none"` is the spelling of an unset `module`, so it derives the
+ * same way.
+ */
+function effectiveModuleKind(options) {
+    const declared = (options.module ?? "").toLowerCase();
+    if (declared !== "" && declared !== "none") {
+        return declared;
+    }
+    const target = (options.target ?? "").toLowerCase();
+    if (target === "esnext") {
+        return "esnext";
+    }
+    const year = scriptTargetYear(target);
+    if (year === null) {
+        // An unset `target` is `ScriptTargetLatestStandard` upstream, well above the
+        // ES2022 boundary. Every other spelling lands here too: TypeScript 7 removed
+        // `ES5` and dropped `ES3` entirely, and its only remaining targets are
+        // year-numbered ones, so nothing that reaches emit derives CommonJS.
+        return "es2022";
+    }
+    if (year >= 2022)
+        return "es2022";
+    if (year >= 2020)
+        return "es2020";
+    return "es2015";
+}
+/**
+ * Year of an `ES<year>` script target, with `es6` normalized to its `es2015`
+ * synonym. Returns `null` when the spelling is not a year-numbered target,
+ * which the caller resolves to the modern default.
+ */
+function scriptTargetYear(target) {
+    if (target === "es6") {
+        return 2015;
+    }
+    const match = /^es(\d{4})$/.exec(target);
+    return match === null ? null : Number(match[1]);
+}
 /** Package-type cache keyed by directory, mirroring Node's own lookup walk. */
 const packageTypeCache = new Map();
 function nearestPackageType(filename) {
@@ -1725,6 +1966,40 @@ function readPackageType(directory) {
         return "commonjs";
     }
 }
+/**
+ * The `"type"` the nearest `package.json` states outright, or `null` when the
+ * nearest manifest omits it (or there is none).
+ *
+ * `nearestPackageType` answers "what format would Node use", which defaults a
+ * silent manifest to CommonJS. This answers the narrower question "did a
+ * package actually say", which is what an override has to be built on: a
+ * manifest that says nothing must not out-vote the compiling project's own
+ * `module` option.
+ */
+function declaredPackageType(filename) {
+    let directory = node_path_1.default.dirname(filename);
+    while (true) {
+        const manifestPath = node_path_1.default.join(directory, "package.json");
+        if (isFile(manifestPath)) {
+            try {
+                const parsed = JSON.parse(node_fs_1.default.readFileSync(manifestPath, "utf8"));
+                // The walk stops at the first manifest either way, exactly as Node's
+                // package-scope lookup does; only the answer differs.
+                return parsed.type === "module" || parsed.type === "commonjs"
+                    ? parsed.type
+                    : null;
+            }
+            catch {
+                return null;
+            }
+        }
+        const parent = node_path_1.default.dirname(directory);
+        if (parent === directory) {
+            return null;
+        }
+        directory = parent;
+    }
+}
 function isRelativeSpecifier(specifier) {
     return (specifier === "." ||
         specifier === ".." ||