ttsc 0.28.6 → 0.30.0

package/lib/launcher/internal/runtimeHooks.js

@@ -31,7 +31,25 @@ const runBuild_1 = require("../../compiler/internal/runBuild");
 const spawnNative_1 = require("../../compiler/internal/spawnNative");
 const createCanonicalTempDirectory_1 = require("../../internal/createCanonicalTempDirectory");
 const projectInputPathIdentity_1 = require("../../internal/projectInputPathIdentity");
+const commonJsExportMetadata_1 = require("./commonJsExportMetadata");
+const runtimeCompilerArgs_1 = require("./runtimeCompilerArgs");
 const servedSourceMap_1 = require("./servedSourceMap");
+/**
+ * One emit policy for orphan execution and CommonJS export discovery. The
+ * compiler ignores the consumer's config, lowers proposal syntax, and checks no
+ * types because the entry build owns diagnostics. Isolation prevents imported
+ * const-enum inlining and secondary emits, and keeps const enums as runtime
+ * exports that the name scanner must also observe.
+ */
+const ISOLATED_EMIT_ARGS = [
+    "--ignoreConfig",
+    "--target",
+    "es2022",
+    "--noCheck",
+    "--skipLibCheck",
+    "--noResolve",
+    "--isolatedModules",
+];
 /**
  * Synchronous Node module hooks installed (via `module.registerHooks`) in the
  * child process `ttsx` spawns to run a TypeScript entry _from source_.
@@ -50,11 +68,9 @@ const servedSourceMap_1 = require("./servedSourceMap");
  *    type-stripping cannot do cross-file type-only elision — e.g. a
  *    value-shaped import of a type+namespace merge survives stripping and
  *    dangles at runtime.
- * 3. No owning tsconfig → transform the lone file by the format it resolves to: a
- *    CommonJS-classified file (`.cts`, or a `.ts` in a package without `type:
- *    "module"`) is lowered to CommonJS through a tsgo single-file emit so its
- *    `export` syntax becomes `module.exports`; any other (ESM) file keeps the
- *    fast in-process `mode: "transform"` type-strip.
+ * 3. No owning tsconfig: use an isolated tsgo emit in the runtime module format,
+ *    lowering standard decorators and CommonJS imports/exports. Type stripping
+ *    remains recovery when no compiler emit is available.
  *
  * The hooks are synchronous and run on the main thread (not a loader worker):
  * that is what lets a CommonJS `require("./x")` chain reach them and what makes
@@ -793,7 +809,7 @@ function owningModuleOptions(filename) {
         // 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.
+        // fails and the file falls through to the isolated orphan emit.
         moduleOptionsCache.set(tsconfig, null);
         return null;
     }
@@ -916,9 +932,8 @@ function projectModuleOptions(compilerOptions) {
 /**
  * Resolve the JavaScript to run for a TypeScript source file, in priority
  * order: the entry project's pre-built emit (transform plugins applied), a
- * built raw `.ts` dependency, or — when no tsconfig owns it — a `mode:
- * "transform"` type-strip. Shared by the ESM `load` hook and the CommonJS
- * `require` handler.
+ * built raw `.ts` dependency, or an isolated emit when no tsconfig owns it.
+ * Shared by the ESM `load` hook and the CommonJS `require` handler.
  */
 function resolveServedSource(filename, url = (0, node_url_1.pathToFileURL)(filename).href, prepareAsEntry = false) {
     const real = realPath(filename);
@@ -960,7 +975,8 @@ function resolveServedSource(filename, url = (0, node_url_1.pathToFileURL)(filen
  * map's `sources`, so the JavaScript executed under the `.ts` source URL stays
  * self-describing after the per-run emit directory is deleted. Applied to both
  * the entry lane (`serveEntryEmit`) and the dependency lane
- * (`serveBuiltDependency`); the orphan type-strip lane carries no emitted map.
+ * (`serveBuiltDependency`); the orphan lane inlines its own map before
+ * caching.
  */
 function withInlineSourceMap(served) {
     const source = (0, servedSourceMap_1.inlineServedSourceMap)(served.source, served.emittedFile, served.sourceFile);
@@ -971,23 +987,16 @@ function withInlineSourceMap(served) {
  * vendored package that ships raw `.ts`/`.cts`/`.mts` straight under
  * `node_modules`), choosing the lowering by the format the file resolves to.
  *
- * Node's in-process `stripTypeScriptTypes` only erases type syntax; it never
- * rewrites ECMAScript `import`/`export` into CommonJS. That is correct for a
- * file Node will load as ESM, but wrong for one classified CommonJS — a `.cts`,
- * or a `.ts` in a package without `type: "module"` — when the author wrote it
- * with module syntax (`export const`, `export namespace`, `export function`).
- * Stripping leaves the `export` in place and Node's CommonJS loader dies with
- * `SyntaxError: Unexpected token 'export'`. So a CommonJS-format orphan is
- * lowered through a real tsgo `--module commonjs` single-file emit (which also
- * handles `export =`), exactly the format decision tsgo would have made for an
- * owning project; an ESM-format orphan keeps the fast in-process strip.
+ * Both module formats need the compiler: Node's type stripping neither lowers
+ * standard decorators nor rewrites ESM exports for CommonJS. Use the existing
+ * single-file emit with the file's own module format and a standard target.
+ * Retain stripping as recovery when no compiler emit is available.
  */
 function transformOrphanSource(filename, url) {
-    if (moduleFormat(filename, null) === "commonjs") {
-        const lowered = emitOrphanAsCommonJs(filename);
-        if (lowered !== null) {
-            return lowered;
-        }
+    const format = moduleFormat(filename, null) === "commonjs" ? "commonjs" : "module";
+    const lowered = emitOrphanSource(filename, format);
+    if (lowered !== null) {
+        return lowered;
     }
     return (0, node_module_1.stripTypeScriptTypes)(node_fs_1.default.readFileSync(filename, "utf8"), {
         mode: "transform",
@@ -995,13 +1004,12 @@ function transformOrphanSource(filename, url) {
     });
 }
 /**
- * Lower a single CommonJS-format source file to CommonJS JavaScript by running
- * tsgo on the lone file with `--module commonjs`. Emit-only, no diagnostic gate
- * (the entry project's up-front check is the type gate), matching
- * `buildDependency`. Returns `null` when tsgo is unavailable or produced no
- * output, so the caller can fall back to the in-process strip.
+ * Lower a single source file to its runtime module format. Emit-only, no
+ * diagnostic gate (the entry project's up-front check is the type gate),
+ * matching `buildDependency`. Returns `null` when tsgo is unavailable or
+ * produced no output, so the caller can fall back to the in-process strip.
  */
-function emitOrphanAsCommonJs(filename) {
+function emitOrphanSource(filename, format) {
     let tsgo;
     try {
         tsgo = (0, resolveTsgo_1.resolveTsgo)({ cwd: node_path_1.default.dirname(filename) }).binary;
@@ -1009,12 +1017,12 @@ function emitOrphanAsCommonJs(filename) {
     catch {
         return null;
     }
-    // Content-hash cache: a CJS-format orphan ('s tsgo single-file emit) is lowered
+    // Content-hash cache: an orphan's tsgo single-file emit is lowered
     // once and reused by every other process in the run, and across runs. Without
     // it a program that fans out into many processes (the automated test corpus
     // imports the same vendored `.ts` deps from thousands of generated files) would
     // re-spawn tsgo per file per process and crawl.
-    const cacheFile = orphanCacheFile(filename, tsgo);
+    const cacheFile = orphanCacheFile(filename, tsgo, format);
     if (cacheFile !== null) {
         const hit = readFileOrNull(cacheFile);
         if (hit !== null) {
@@ -1025,29 +1033,20 @@ function emitOrphanAsCommonJs(filename) {
     try {
         const res = (0, spawnNative_1.spawnNative)(tsgo, [
             filename,
-            // The file is named on the command line, so any tsconfig tsgo would
-            // discover by walking up (the consumer's own) must be ignored — both
-            // because it is not this file's project and because tsgo errors out
-            // ("tsconfig.json is present but will not be loaded") otherwise.
-            "--ignoreConfig",
             "--module",
-            "commonjs",
-            "--target",
-            "es2022",
-            // This is an emit-only lowering: the entry project's up-front build is
-            // the type gate, so the single-file pass does not need to type-check.
-            // Skipping the check (and the lib check it implies) cuts the per-file
-            // cost several-fold, which matters when a program generates and imports
-            // thousands of raw `.ts` files at runtime (a fanned-out test corpus) and
-            // each one would otherwise pay a full single-file check.
-            "--noCheck",
-            "--skipLibCheck",
+            format === "commonjs" ? "commonjs" : "esnext",
+            ...ISOLATED_EMIT_ARGS,
+            "--sourceMap",
+            "--inlineSources",
             "--outDir",
             outDir,
             "--listEmittedFiles",
         ], { cwd: node_path_1.default.dirname(filename), encoding: "utf8" });
-        const emitted = parseFirstEmittedFile((0, spawnNative_1.outputText)(res.stdout));
-        const lowered = emitted === null ? null : readFileOrNull(emitted);
+        const emitted = pickEmittedJavaScript(filename, parseEmittedFiles((0, spawnNative_1.outputText)(res.stdout)));
+        const source = emitted === null ? null : readFileOrNull(emitted);
+        const lowered = source === null
+            ? null
+            : (0, servedSourceMap_1.inlineServedSourceMap)(source, emitted, filename);
         if (lowered !== null && cacheFile !== null) {
             writeOrphanCache(cacheFile, lowered);
         }
@@ -1061,7 +1060,10 @@ function emitOrphanAsCommonJs(filename) {
     }
 }
 /**
- * Emit a source file only for CommonJS export-name discovery.
+ * Read actual owned output for CommonJS export-name discovery, falling back to
+ * isolated emission only when no project emitted this source. Project
+ * transforms and const-enum settings decide which names exist at runtime. An
+ * ESM emit is lowered as JavaScript solely to scan its CommonJS names.
  *
  * This intentionally does not read or write the runtime orphan cache. Name
  * discovery may inspect a source dependency without executing it, so sharing
@@ -1074,6 +1076,12 @@ function emitCommonJsForNameScan(filename) {
     if (cached !== undefined) {
         return cached;
     }
+    const served = serveEntryEmit(real) ?? serveDependencyEmit(real);
+    if (served !== null &&
+        moduleFormat(real, served.moduleOptions) === "commonjs") {
+        commonJsNameScanSources.set(real, served.source);
+        return served.source;
+    }
     let tsgo;
     try {
         tsgo = (0, resolveTsgo_1.resolveTsgo)({ cwd: node_path_1.default.dirname(real) }).binary;
@@ -1084,20 +1092,21 @@ function emitCommonJsForNameScan(filename) {
     }
     const outDir = (0, createCanonicalTempDirectory_1.createCanonicalTempDirectory)("ttsx-export-scan-");
     try {
+        // Compile the owned JavaScript, not the original TypeScript whose project
+        // may already have erased or transformed declarations. No source executes.
+        const input = served === null ? real : node_path_1.default.join(outDir, "source.cts");
+        if (served !== null)
+            node_fs_1.default.writeFileSync(input, served.source);
         const res = (0, spawnNative_1.spawnNative)(tsgo, [
-            real,
-            "--ignoreConfig",
+            input,
             "--module",
             "commonjs",
-            "--target",
-            "es2022",
-            "--noCheck",
-            "--skipLibCheck",
+            ...ISOLATED_EMIT_ARGS,
             "--outDir",
             outDir,
             "--listEmittedFiles",
         ], { cwd: node_path_1.default.dirname(real), encoding: "utf8" });
-        const emitted = pickEmittedJavaScript(real, parseEmittedFiles((0, spawnNative_1.outputText)(res.stdout)));
+        const emitted = pickEmittedJavaScript(input, parseEmittedFiles((0, spawnNative_1.outputText)(res.stdout)));
         const lowered = emitted === null ? null : readFileOrNull(emitted);
         commonJsNameScanSources.set(real, lowered);
         return lowered;
@@ -1118,14 +1127,14 @@ function orphanCacheRoot() {
     const base = process.env.TTSC_CACHE_DIR && process.env.TTSC_CACHE_DIR.length !== 0
         ? process.env.TTSC_CACHE_DIR
         : node_path_1.default.join(node_os_1.default.tmpdir(), "ttsc-orphan");
-    return node_path_1.default.join(base, "ttsx-orphan-cjs");
+    return node_path_1.default.join(base, "ttsx-orphan");
 }
 /**
- * Content-addressed cache path for one orphan file's CommonJS lowering, keyed
- * by source bytes and the tsgo binary so a tsgo bump invalidates it. `null`
- * when the source cannot be read.
+ * Content-addressed cache path for isolated orphan lowering, including the
+ * source path because the inlined map identifies that path. `null` when the
+ * source cannot be read.
  */
-function orphanCacheFile(filename, tsgo) {
+function orphanCacheFile(filename, tsgo, format) {
     let source;
     try {
         source = node_fs_1.default.readFileSync(filename);
@@ -1136,6 +1145,9 @@ function orphanCacheFile(filename, tsgo) {
     const key = node_crypto_1.default
         .createHash("sha256")
         .update(tsgo)
+        .update("\0isolated-source-map-v1\0")
+        .update(filename)
+        .update("\0" + format)
         .update("\0")
         .update(source)
         .digest("hex")
@@ -1158,16 +1170,6 @@ function writeOrphanCache(cacheFile, lowered) {
         // ignore — caching is an optimization, correctness does not depend on it
     }
 }
-/** First `TSFILE:` path tsgo printed under `--listEmittedFiles`, or `null`. */
-function parseFirstEmittedFile(stdout) {
-    for (const line of stdout.split(/\r?\n/)) {
-        const match = line.match(/^TSFILE:\s*(.+)$/);
-        if (match?.[1]) {
-            return match[1].trim();
-        }
-    }
-    return null;
-}
 /** `TSFILE:` paths tsgo printed under `--listEmittedFiles`. */
 function parseEmittedFiles(stdout) {
     const files = [];
@@ -1202,35 +1204,30 @@ function pickEmittedJavaScript(filename, emittedFiles) {
  * Runtime CommonJS consumers see the getters that helper installs, but Node's
  * ESM linker only exposes named imports it can statically identify from
  * `exports.name = ...` assignments. For relative star re-exports whose emitted
- * target is available, replace the helper call with explicit configurable
- * export placeholders followed by the same `__createBinding` getter install.
+ * target is available, advertise its names through inert assignments that
+ * Node's static lexer recognizes. The original helper still owns every runtime
+ * binding, including values static discovery cannot enumerate.
  */
 function exposeCommonJsStarExports(source, emittedFile, sourceFile) {
-    if (!source.includes("__exportStar(")) {
-        return source;
+    const parsed = (0, commonJsExportMetadata_1.parseCommonJsExports)(source);
+    const reserved = new Set(parsed.exports);
+    const names = new Set();
+    for (const specifier of parsed.reexports) {
+        for (const name of collectStarExportNames(emittedFile, sourceFile, specifier)) {
+            if (name !== "default" && name !== "__esModule" && !reserved.has(name)) {
+                names.add(name);
+            }
+        }
     }
-    const reserved = collectStaticCommonJsExportNames(source);
-    let index = 0;
-    return source.replace(/^(\s*)__exportStar\(\s*require\((["'])([^"']+)\2\)\s*,\s*exports\s*\);/gm, (statement, indent, _quote, specifier) => {
-        const names = [
-            ...collectStarExportNames(emittedFile, sourceFile, specifier),
-        ].filter((name) => name !== "default" &&
-            name !== "__esModule" &&
-            isIdentifierName(name) &&
-            !reserved.has(name));
-        if (names.length === 0) {
-            return statement;
-        }
-        for (const name of names) {
-            reserved.add(name);
-        }
-        const receiver = `__ttsx_export_star_${index++}`;
-        return [
-            ...names.map((name) => `${indent}exports.${name} = void 0;`),
-            `${indent}var ${receiver} = require(${JSON.stringify(specifier)});`,
-            ...names.map((name) => `${indent}__createBinding(exports, ${receiver}, ${JSON.stringify(name)});`),
-        ].join("\n");
-    });
+    if (names.size === 0)
+        return source;
+    // Node's lexer reads these assignments statically. Nothing executes, and no
+    // existing statement, source position, control-flow body or runtime export
+    // is changed. Keep all specifier/literal parsing in the same lexer Node uses.
+    const hints = [...names]
+        .map((name) => `exports[${JSON.stringify(name)}] = void 0;`)
+        .join(" ");
+    return source + `\nif (false) { ${hints} }\n`;
 }
 function collectStarExportNames(emittedFile, sourceFile, specifier) {
     if (emittedFile !== undefined) {
@@ -1257,8 +1254,9 @@ function collectCommonJsExportNames(emittedFile, seen) {
     if (source === null) {
         return new Set();
     }
-    const names = collectStaticCommonJsExportNames(source);
-    for (const specifier of collectExportStarSpecifiers(source)) {
+    const parsed = (0, commonJsExportMetadata_1.parseCommonJsExports)(source);
+    const names = new Set(parsed.exports);
+    for (const specifier of parsed.reexports) {
         const target = resolveEmittedRequire(real, specifier);
         if (target === null) {
             continue;
@@ -1271,153 +1269,6 @@ function collectCommonJsExportNames(emittedFile, seen) {
     }
     return names;
 }
-function collectStaticCommonJsExportNames(source) {
-    // Scan executable syntax only. Text that merely resembles an assignment —
-    // `exports.x =` inside a comment, string, or template-literal text — must not
-    // become an ESM-visible export name, or a named import of it would link to
-    // `undefined` for a property the CommonJS module never defines. Masking the
-    // inert lexical spans before matching keeps genuine top-level assignments
-    // (and executable `${ ... }` template substitutions) while dropping the
-    // decoys.
-    const scannable = maskCommentsAndStrings(source);
-    const names = new Set();
-    const pattern = /(?:^|[^\w$])(?:exports|module\.exports)\.([A-Za-z_$][\w$]*)\s*=/g;
-    let match;
-    while ((match = pattern.exec(scannable)) !== null) {
-        names.add(match[1]);
-    }
-    return names;
-}
-/**
- * Blank out the interior of line comments, block comments, string literals, and
- * template-literal text in emitted JavaScript, replacing each masked character
- * with a space while preserving newlines, code, and template `${ ... }`
- * substitutions verbatim. Positions and length are preserved so an offset in
- * the masked text maps back to the same offset in the source.
- *
- * The input is tsgo's CommonJS emit (well-formed JavaScript), so a character
- * scanner that tracks the standard comment/string/template states is sufficient
- * to separate executable tokens from inert text. Regular-expression literals
- * are intentionally not masked: distinguishing `/`-division from a regex
- * literal needs full tokenization, and tsgo's CommonJS emit never wraps an
- * `exports.<name> =` assignment inside a regex literal.
- */
-function maskCommentsAndStrings(source) {
-    const out = source.split("");
-    const n = out.length;
-    const blank = (index) => {
-        const ch = out[index];
-        if (ch !== "\n" && ch !== "\r") {
-            out[index] = " ";
-        }
-    };
-    const stack = [{ kind: "code", braceDepth: 0 }];
-    let i = 0;
-    while (i < n) {
-        const top = stack[stack.length - 1];
-        const ch = out[i];
-        if (top.kind === "template") {
-            if (ch === "\\") {
-                blank(i);
-                blank(i + 1);
-                i += 2;
-                continue;
-            }
-            if (ch === "`") {
-                blank(i);
-                stack.pop();
-                i += 1;
-                continue;
-            }
-            if (ch === "$" && out[i + 1] === "{") {
-                // Enter a code substitution: `${` and its contents stay executable.
-                stack.push({ kind: "code", braceDepth: 0 });
-                i += 2;
-                continue;
-            }
-            blank(i);
-            i += 1;
-            continue;
-        }
-        // Code context.
-        if (ch === "/" && out[i + 1] === "/") {
-            blank(i);
-            blank(i + 1);
-            i += 2;
-            while (i < n && out[i] !== "\n") {
-                blank(i);
-                i += 1;
-            }
-            continue;
-        }
-        if (ch === "/" && out[i + 1] === "*") {
-            blank(i);
-            blank(i + 1);
-            i += 2;
-            while (i < n && !(out[i] === "*" && out[i + 1] === "/")) {
-                blank(i);
-                i += 1;
-            }
-            if (i < n) {
-                blank(i);
-                blank(i + 1);
-                i += 2;
-            }
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            blank(i);
-            i += 1;
-            while (i < n && out[i] !== ch) {
-                if (out[i] === "\\") {
-                    blank(i);
-                    blank(i + 1);
-                    i += 2;
-                    continue;
-                }
-                // A bare newline ends an unterminated string; stop masking so the rest
-                // of the line is still scanned as code (defensive — tsgo never emits
-                // one).
-                if (out[i] === "\n") {
-                    break;
-                }
-                blank(i);
-                i += 1;
-            }
-            if (i < n && out[i] === ch) {
-                blank(i);
-                i += 1;
-            }
-            continue;
-        }
-        if (ch === "`") {
-            blank(i);
-            stack.push({ kind: "template", braceDepth: 0 });
-            i += 1;
-            continue;
-        }
-        if (ch === "{") {
-            top.braceDepth += 1;
-            i += 1;
-            continue;
-        }
-        if (ch === "}") {
-            if (top.braceDepth === 0 && stack.length > 1) {
-                // Close the enclosing template `${ ... }` and resume template text.
-                stack.pop();
-                i += 1;
-                continue;
-            }
-            if (top.braceDepth > 0) {
-                top.braceDepth -= 1;
-            }
-            i += 1;
-            continue;
-        }
-        i += 1;
-    }
-    return out.join("");
-}
 function collectSourceCommonJsExportNames(sourceFile, seen) {
     const real = realPath(sourceFile);
     if (seen.has(real)) {
@@ -1428,8 +1279,9 @@ function collectSourceCommonJsExportNames(sourceFile, seen) {
     if (source === null) {
         return new Set();
     }
-    const names = collectStaticCommonJsExportNames(source);
-    for (const specifier of collectExportStarSpecifiers(source)) {
+    const parsed = (0, commonJsExportMetadata_1.parseCommonJsExports)(source);
+    const names = new Set(parsed.exports);
+    for (const specifier of parsed.reexports) {
         const target = resolveSourceSpecifier(real, specifier);
         if (target === null) {
             continue;
@@ -1442,15 +1294,6 @@ function collectSourceCommonJsExportNames(sourceFile, seen) {
     }
     return names;
 }
-function collectExportStarSpecifiers(source) {
-    const specifiers = [];
-    const pattern = /^(\s*)__exportStar\(\s*require\((["'])([^"']+)\2\)\s*,\s*exports\s*\);/gm;
-    let match;
-    while ((match = pattern.exec(source)) !== null) {
-        specifiers.push(match[3]);
-    }
-    return specifiers;
-}
 function resolveEmittedRequire(emittedFile, specifier) {
     if (!isRelativeSpecifier(specifier)) {
         return null;
@@ -1479,7 +1322,9 @@ function resolveSourceSpecifier(sourceFile, specifier) {
     }
     const base = node_path_1.default.resolve(node_path_1.default.dirname(sourceFile), specifier);
     if (node_path_1.default.extname(base).length !== 0) {
-        return isFile(base) ? base : null;
+        if (isFile(base))
+            return base;
+        return typescriptSourcesForJavaScriptSpecifier(base).find(isFile) ?? null;
     }
     for (const extension of TYPESCRIPT_EXTENSIONS) {
         const candidate = base + extension;
@@ -1495,9 +1340,6 @@ function resolveSourceSpecifier(sourceFile, specifier) {
     }
     return null;
 }
-function isIdentifierName(name) {
-    return /^[A-Za-z_$][\w$]*$/.test(name);
-}
 /**
  * Serve the entry project's pre-built JavaScript for a source file the build
  * emitted, or `null` when the file is outside the build or its emit is
@@ -1629,7 +1471,7 @@ function serveDependencyEmit(real) {
         built = ensureProjectBuilt(tsconfig);
     }
     catch {
-        // The owning project produced no emit at all; fall back to type-stripping
+        // The owning project produced no emit at all; fall back to isolated emit of
         // this single file rather than failing the whole run.
         return null;
     }
@@ -1703,6 +1545,7 @@ function dependencyCacheKey(tsconfig, options = {}) {
     return (node_crypto_1.default
         .createHash("sha256")
         .update(tsconfig)
+        .update("\0runtime-es2025")
         // Descriptor evaluation promises a result bound to this process's exact
         // input observations. Reusing an emit another evaluator built can pair
         // that process's old source/config bytes with this process's later hashes.
@@ -1850,6 +1693,7 @@ function buildDependency(tsconfig, cacheDir, metaPath) {
     node_fs_1.default.mkdirSync(emitDir, { recursive: true });
     const result = (0, runBuild_1.runBuild)({
         cwd: project.root,
+        passthrough: (0, runtimeCompilerArgs_1.runtimeCompilerArgs)(project),
         emit: true,
         forceListEmittedFiles: true,
         outDir: emitDir,
@@ -1891,7 +1735,7 @@ function buildDependency(tsconfig, cacheDir, metaPath) {
     // list": a native transform host (typia, @ttsc/banner, …) emits without
     // printing the `--listEmittedFiles` lines, so `result.emittedFiles` is empty
     // even on a clean build. A genuinely empty output directory is the real
-    // failure; the caller then falls back to type-stripping the one file.
+    // failure; the caller then falls back to isolated emit of the one file.
     if (!emittedAnything(emitDir)) {
         // Drop the failed generation so its partial directory can never be mistaken
         // for a reusable build.
@@ -2231,8 +2075,8 @@ const moduleOptionsCache = new Map();
  * walk stops at a `node_modules` boundary: a tsconfig above `node_modules`
  * belongs to the consumer, not to the published dependency inside it, so a
  * dependency that ships no tsconfig of its own has no owning project and is
- * type-stripped instead. A pnpm-symlinked workspace package is unaffected
- * because `file` is already its real path (outside `node_modules`).
+ * compiled in isolation instead. A pnpm-symlinked workspace package is
+ * unaffected because `file` is already its real path (outside `node_modules`).
  *
  * The walk is memoised per directory (the whole walked chain shares one
  * answer), so the thousands of files a fanned-out test corpus imports from the