ttsc 0.26.1 → 0.27.0

package/src/compiler/internal/runBuild.ts

@@ -6,6 +6,7 @@ import {
   type ProjectInputPathIdentityContext,
   createProjectInputPathIdentityContext,
 } from "../../internal/projectInputPathIdentity";
+import { resolveNodeBinary } from "../../internal/resolveNodeBinary";
 import {
   hasProjectPluginEntries,
   loadProjectPlugins,
@@ -26,7 +27,10 @@ import {
 import { resolveBinary } from "./resolveBinary";
 import { resolveTsgo } from "./resolveTsgo";
 import {
+  TSGO_ARGS_ENV,
   assertSharedHostCompatibility,
+  clearInheritedTsgoArgs,
+  inheritedSidecarEnv,
   linkedTransformPlugins,
   resolvePluginConfigDir,
   selectSharedHostPlugin,
@@ -38,6 +42,34 @@ export type RunBuildOptions = TtscBuildOptions & {
   forceListEmittedFiles?: boolean;
   /** Keep every compiler-owned side product inside this private directory. */
   isolateOutputsTo?: string;
+  /**
+   * Hand tsgo the `rootDir` it would otherwise infer, for a build whose
+   * `outDir` this process injected rather than the project declaring it.
+   *
+   * Tsgo answers an inferred common source directory with TS5011 the moment an
+   * `outDir` is in play, so injecting one turns a project that declares no
+   * output at all — the `noEmit` check-only shape `tsgo`, `ttsc`, and `ttsc
+   * --emit` all accept — into one that must configure the layout of output the
+   * user never asked for and never sees (issue #1172).
+   *
+   * The pinned value is the one tsgo itself infers: with a config file in play
+   * its common source directory is that file's directory, never the computed
+   * common directory of the input files (`outputpaths.GetCommonSourceDirectory`
+   * consults the file list only for a config-less program). Pinning it
+   * therefore silences the demand without moving a single output, and it is the
+   * same source root `prepareExecution.ts::resolveRuntimeSourceRoot`,
+   * `runtimeHooks.ts::resolveDependencySourceRoot`, and
+   * `watchTopology.ts::inferPerSourceCompilerOutputs` already model on the
+   * JavaScript side.
+   *
+   * Ignored when the project declares its own `rootDir`: that project already
+   * satisfies tsgo, and overriding it would relocate the emit out from under
+   * every consumer that mirrors the declared root.
+   *
+   * Never set for a user-supplied `--outDir`. That outDir is the user's own
+   * request, and TS5011 is then tsgo's genuine answer to it.
+   */
+  pinInferredRootDir?: boolean;
   /**
    * Receives selected native-plugin source roots after the project resolves.
    * The watch launcher uses these roots to invalidate a sidecar when its Go
@@ -73,13 +105,18 @@ type BuildTiming = {
  * `TTSC_NODE_BINARY` so child processes can re-invoke the same Node.js binary
  * without searching `PATH`.
  */
-function mergeEnv(extra?: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
-  const base = {
+function mergeEnv(
+  extra?: NodeJS.ProcessEnv,
+  cwd: string = process.cwd(),
+): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = {
     ...process.env,
-    TTSC_NODE_BINARY: process.env.TTSC_NODE_BINARY ?? process.execPath,
+    ...extra,
   };
-  if (!extra) return base;
-  return { ...base, ...extra };
+  const node = resolveNodeBinary(env, cwd);
+  if (node === undefined) delete env.TTSC_NODE_BINARY;
+  else env.TTSC_NODE_BINARY = node;
+  return env;
 }
 
 function createBuildTiming(options: TtscCommonOptions): BuildTiming {
@@ -170,17 +207,29 @@ function nativePluginEnv(
   extra: NodeJS.ProcessEnv | undefined,
   execution: ReturnType<typeof resolveExecutionContext>,
   plugin?: ITtscLoadedNativePlugin,
+  tsgoArgs?: string,
 ): NodeJS.ProcessEnv {
-  const env = mergeEnv({
-    ...(execution.pluginConfigDir === undefined
-      ? {}
-      : { TTSC_PLUGIN_CONFIG_DIR: execution.pluginConfigDir }),
-    TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? execution.tsgo.binary,
-    TTSC_TTSX_BINARY:
-      process.env.TTSC_TTSX_BINARY ??
-      path.join(__dirname, "..", "..", "launcher", "ttsx.js"),
-    ...extra,
-  });
+  const env = mergeEnv(
+    {
+      ...(execution.pluginConfigDir === undefined
+        ? {}
+        : { TTSC_PLUGIN_CONFIG_DIR: execution.pluginConfigDir }),
+      TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? execution.tsgo.binary,
+      TTSC_TTSX_BINARY:
+        process.env.TTSC_TTSX_BINARY ??
+        path.join(__dirname, "..", "..", "launcher", "ttsx.js"),
+      ...extra,
+    },
+    execution.projectRoot,
+  );
+  // Forwarded tsgo argv is per-invocation state this host owns, exactly like
+  // the config anchor below: publish this run's payload, or drop whatever an
+  // ancestor ttsc process left behind when this lane forwards nothing.
+  if (tsgoArgs !== undefined) {
+    env[TSGO_ARGS_ENV] = tsgoArgs;
+  } else {
+    clearInheritedTsgoArgs(env, extra);
+  }
   // The anchor is per-invocation state owned by this host: when this run
   // declared none (and the caller's env does not name one), drop any value
   // inherited from an ancestor ttsc process so a nested build never
@@ -363,8 +412,11 @@ export class ResidentCheckWatchSession {
       stderr: "",
       stdout: "",
     };
-    const checks = planResidentCheckEntries(execution.nativePlugins, (plugin) =>
-      createNativeCheckArgs(execution, options, plugin),
+    const tsgoArgs = createNativeTsgoArgs(options);
+    const checks = planResidentCheckEntries(
+      execution.nativePlugins,
+      (plugin) => createNativeCheckArgs(execution, options, plugin),
+      tsgoArgs,
     );
     const request = residentCheckRequest(change, execution.projectRoot);
     // Buffer the cycle for every resident plugin before running any of them.
@@ -383,6 +435,7 @@ export class ResidentCheckWatchSession {
           "ttsc.check",
           timing,
           `ttsc check plugin ${plugin.name} time`,
+          tsgoArgs,
         );
       } else {
         const startedAt = process.hrtime.bigint();
@@ -392,7 +445,7 @@ export class ResidentCheckWatchSession {
             args: ["check-serve", ...args.slice(1)],
             binary: plugin.binary,
             cwd: execution.projectRoot,
-            env: nativePluginEnv(options.env, execution, plugin),
+            env: nativePluginEnv(options.env, execution, plugin, tsgoArgs),
           });
           this.processes.set(key, resident);
         }
@@ -478,8 +531,9 @@ function residentCheckExecutionIsCompatible(
 function residentCheckProcessKey(
   plugin: ITtscLoadedNativePlugin,
   args: readonly string[],
+  tsgoArgs?: string,
 ): string {
-  return `${plugin.binary}\0${plugin.name}\0${JSON.stringify(args)}`;
+  return `${plugin.binary}\0${plugin.name}\0${JSON.stringify(args)}\0${tsgoArgs ?? ""}`;
 }
 
 export type ResidentCheckEntryPlan = {
@@ -496,6 +550,11 @@ export type ResidentCheckEntryPlan = {
 export function planResidentCheckEntries(
   plugins: readonly ITtscLoadedNativePlugin[],
   createArgs: (plugin: ITtscLoadedNativePlugin) => string[],
+  // Part of the process identity even though it never appears in argv: the
+  // forwarded tsgo payload rides the environment, and a resident process holds
+  // the compiler options it was started with. Two cycles that forward different
+  // flags must not share one warm Program.
+  tsgoArgs?: string,
 ): ResidentCheckEntryPlan[] {
   return plugins
     .filter((candidate) => candidate.stage === "check")
@@ -506,7 +565,7 @@ export function planResidentCheckEntries(
         entryIndex,
         key:
           plugin.capabilities?.residentCheck === true
-            ? residentCheckProcessKey(plugin, args)
+            ? residentCheckProcessKey(plugin, args, tsgoArgs)
             : undefined,
         plugin,
       };
@@ -802,7 +861,7 @@ function runProjectFreeTerminalFlag(
   const tsgo = resolveTsgo({ ...options, cwd });
   const res = spawnNative(tsgo.binary, [...(options.passthrough ?? [])], {
     cwd,
-    env: mergeEnv(options.env),
+    env: mergeEnv(options.env, cwd),
     encoding: "utf8",
   });
   if (res.error) {
@@ -1084,7 +1143,7 @@ function forwardsInternalShadowFlag(
  * inside it via the `--plugins-json` flag.
  */
 function buildWithNativeCompilerPlugins(
-  options: TtscBuildOptions,
+  options: RunBuildOptions,
   execution: ReturnType<typeof resolveExecutionContext>,
   plugins: readonly ITtscLoadedNativePlugin[],
   timing: BuildTiming,
@@ -1098,6 +1157,7 @@ function buildWithNativeCompilerPlugins(
     "ttsc.build",
     timing,
     transformHostTimingLabel(plugins),
+    createNativeBuildTsgoArgs(execution, options),
   );
 }
 
@@ -1122,7 +1182,7 @@ function runTsgo(
     ],
     {
       cwd: execution.projectRoot,
-      env: mergeEnv(options.env),
+      env: mergeEnv(options.env, execution.projectRoot),
       encoding: "utf8",
     },
   );
@@ -1156,7 +1216,7 @@ function runTsgoBuild(
 ): TtscBuildResult {
   const res = spawnNative(execution.tsgo.binary, args, {
     cwd: execution.projectRoot,
-    env: mergeEnv(options.env),
+    env: mergeEnv(options.env, execution.projectRoot),
     encoding: "utf8",
   });
   if (res.error) {
@@ -1245,6 +1305,9 @@ function createTsgoBuildArgs(
     if (options.forceRuntimeSourceMap === true) {
       args.push("--sourceMap", "true");
     }
+    // Pushed before passthrough for the same reason: a user `--rootDir` still
+    // wins over the value ttsc pins for its own injected `outDir`.
+    args.push(...pinnedRootDirArgs(execution, options));
   } else if (options.emit === false) {
     args.push("--noEmit");
   }
@@ -1264,6 +1327,37 @@ function createTsgoBuildArgs(
   return args;
 }
 
+/**
+ * The explicit `--rootDir` a caller-injected `outDir` needs, or nothing.
+ *
+ * See {@link RunBuildOptions.pinInferredRootDir} for why an injected `outDir`
+ * needs one at all. Three conditions gate it, and each one is load-bearing:
+ *
+ * - The caller injected the `outDir` itself, so a user `--outDir` keeps tsgo's
+ *   own TS5011 answer;
+ * - This pass emits, because a no-emit pass has no layout to pin (tsgo skips the
+ *   check for `noEmit` too);
+ * - The project declares no `rootDir` of its own, so a declared layout is never
+ *   overridden.
+ *
+ * `execution.projectRoot` is the directory of the tsconfig ttsc resolved and
+ * hands tsgo as `-p`, which is exactly the directory tsgo infers, and it is
+ * spelled the way tsgo will spell the input file names it compares against it —
+ * both come from the same `fs.realpathSync` pass. Resolving it any further (a
+ * Windows 8.3 expansion, say) would leave the comparison lexically mixed, and
+ * `ContainsPath` is lexical: every input would count as outside `rootDir` and
+ * tsgo would emit it beside the user's source instead of under `outDir`.
+ */
+function pinnedRootDirArgs(
+  execution: ReturnType<typeof resolveExecutionContext>,
+  options: RunBuildOptions,
+): string[] {
+  if (options.pinInferredRootDir !== true) return [];
+  if (options.emit !== true) return [];
+  if (typeof execution.project.compilerOptions.rootDir === "string") return [];
+  return ["--rootDir", execution.projectRoot];
+}
+
 /**
  * Return `["--pretty", "false"]` when structured diagnostics are requested so
  * that the output can be parsed line-by-line, or an empty array otherwise.
@@ -1304,7 +1398,7 @@ function createTsgoThreadingArgs(options: TtscCommonOptions): string[] {
 /** Build the argument list for a native plugin `build`/`check` invocation. */
 function createNativeBuildArgs(
   execution: ReturnType<typeof resolveExecutionContext>,
-  options: TtscBuildOptions,
+  options: RunBuildOptions,
   plugins: readonly ITtscLoadedNativePlugin[],
 ): string[] {
   const args = [
@@ -1339,10 +1433,23 @@ function createNativeBuildArgs(
       args.push("--quiet");
     }
   }
-  args.push(...createNativeTsgoArgs(options));
   return args;
 }
 
+/**
+ * The forwarded-tsgo payload for a native `build`/`check` emit invocation.
+ *
+ * The sidecar builds its Program in-process, so the pinned `rootDir` has to
+ * travel the same channel every other tsgo option takes to it — the host flag
+ * set does not declare `--rootDir`, and `filterHostArgs` would strip it.
+ */
+function createNativeBuildTsgoArgs(
+  execution: ReturnType<typeof resolveExecutionContext>,
+  options: RunBuildOptions,
+): string | undefined {
+  return createNativeTsgoArgs(options, pinnedRootDirArgs(execution, options));
+}
+
 /** Build the argument list for a native plugin check/fix/format invocation. */
 function createNativeCheckArgs(
   execution: ReturnType<typeof resolveExecutionContext>,
@@ -1373,7 +1480,6 @@ function createNativeCheckArgs(
   }
   args.push(...createNativeCheckThreadingArgs(options, plugin));
   args.push(...createNativeCheckDiagnosticsArgs(options, plugin));
-  args.push(...createNativeTsgoArgs(options));
   return args;
 }
 
@@ -1483,20 +1589,48 @@ function transformHostTimingLabel(
 
 /**
  * Forward the tsgo flags ttsc did not recognize to a native sidecar as one
- * JSON-encoded `--tsgo-args` flag. The sidecar replays them through tsgo's own
- * option parser onto `CompilerOptions`, so a flag like `ttsc --strict` reaches
- * a plugin build the same way it reaches the plain tsgo lane. Encoded as a
- * single token so the sidecars' unknown-flag filters keep it intact.
+ * JSON-encoded payload. The sidecar replays them through tsgo's own option
+ * parser onto `CompilerOptions`, so a flag like `ttsc --strict` reaches a
+ * plugin build the same way it reaches the plain tsgo lane.
+ *
+ * The payload travels in the `TTSC_TSGO_ARGS` environment variable, not on the
+ * sidecar's command line. #113 shipped it as a `--tsgo-args` flag, which is an
+ * addition to a plugin protocol third-party hosts had already frozen: a Go
+ * `flag.FlagSet` created with `flag.ContinueOnError` treats an undeclared flag
+ * as fatal, so every pre-#113 sidecar answered `flag provided but not defined:
+ * -tsgo-args` and exited 2. That took down `ttsc --strict`, `ttsc
+ * --declaration`, `ttsx --strict` and — because {@link isolatedTsgoOutputArgs}
+ * makes this payload non-empty on its own — plain `ttsc <file.ts>`, on every
+ * project carrying a typia/nestia-era transform host (issue #1188).
+ *
+ * The environment is the channel ttsc already uses for host-owned payloads that
+ * must not collide with a third-party flag set (`TTSC_LINKED_PLUGINS_JSON`,
+ * `TTSC_PLUGIN_CONFIG_DIR`). It reaches those hosts without any change on their
+ * side, because `buildSourcePlugin.ts::sourceBuildWorkspaceReplacements` builds
+ * every source plugin against the installed ttsc's own driver, and
+ * `driver.LoadProgram` reads the variable whenever the caller supplied no
+ * explicit argv. It is strictly better than the capability gate `ad3443a` used
+ * for `--singleThreaded` / `--checkers`: that one drops the flag for hosts that
+ * cannot take it, which is acceptable for a threading knob and not for
+ * `--strict`.
+ *
+ * Returns the JSON payload, or `undefined` when this lane forwards nothing.
  */
-function createNativeTsgoArgs(options: TtscCommonOptions): string[] {
+function createNativeTsgoArgs(
+  options: TtscCommonOptions,
+  leading: readonly string[] = [],
+): string | undefined {
   const passthrough = [
+    // Ahead of the user's own flags, so the same precedence holds here as on
+    // the direct tsgo lane: whatever the user forwarded wins.
+    ...leading,
     ...(nativeTsgoPassthroughArgs(options) ?? []),
     ...isolatedTsgoOutputArgs(options),
   ];
   if (passthrough.length === 0) {
-    return [];
+    return undefined;
   }
-  return ["--tsgo-args=" + JSON.stringify(passthrough)];
+  return JSON.stringify(passthrough);
 }
 
 function isolatedTsgoOutputArgs(options: TtscCommonOptions): string[] {
@@ -1605,6 +1739,7 @@ function runNativeCheckPlugins(
       "ttsc.check",
       timing,
       `ttsc check plugin ${plugin.name} time`,
+      createNativeTsgoArgs(options),
     );
     out = appendBuildOutput(out, result);
     if (result.status !== 0) {
@@ -1876,11 +2011,12 @@ function runNativePluginCommand(
   label: string,
   timing: BuildTiming,
   timingLabel: string,
+  tsgoArgs?: string,
 ): TtscBuildResult {
   const startedAt = process.hrtime.bigint();
   const res = spawnNative(plugin.binary, args, {
     cwd: execution.projectRoot,
-    env: nativePluginEnv(options.env, execution, plugin),
+    env: nativePluginEnv(options.env, execution, plugin, tsgoArgs),
     encoding: "utf8",
   });
   recordTiming(timing, timingLabel, startedAt);
@@ -1974,7 +2110,7 @@ function resolveExecutionContext(
         cacheDir: options.cacheDir ?? options.env?.TTSC_CACHE_DIR,
         cwd,
         entries: options.plugins,
-        env: { ...process.env, ...options.env },
+        env: inheritedSidecarEnv(options.env),
         onWatchInputs: options.onWatchInputs,
         pluginConfigDir: options.pluginConfigDir,
         projectRoot,

package/src/compiler/internal/runSingleFileEmit.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
+import { createCanonicalTempDirectory } from "../../internal/createCanonicalTempDirectory";
 import type { TtscSingleFileEmitOptions } from "../../structures/internal/TtscSingleFileEmitOptions";
 import { readProjectConfig } from "./project/readProjectConfig";
 import { resolveEmittedJavaScript } from "./resolveEmittedJavaScript";
@@ -32,7 +32,7 @@ export function runSingleFileEmit(options: TtscSingleFileEmitOptions): string {
   });
   const tsconfig = project.path;
   const projectRoot = project.root;
-  const outDir = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-single-file-"));
+  const outDir = createCanonicalTempDirectory("ttsc-single-file-");
   try {
     const result = runBuild({
       ...options,
@@ -41,6 +41,13 @@ export function runSingleFileEmit(options: TtscSingleFileEmitOptions): string {
       forceListEmittedFiles: true,
       isolateOutputsTo: outDir,
       outDir,
+      // The private temp directory above is an `outDir` this lane injected, not
+      // one the project declared, and tsgo answers an inferred common source
+      // directory with TS5011 as soon as any `outDir` is in play. Pinning the
+      // root tsgo would infer keeps `ttsc <file.ts>` working on a project that
+      // declares no output at all, and it is the same root
+      // `resolveEmittedJavaScript` mirrors below (issue #1172).
+      pinInferredRootDir: true,
       resolvedProject: project,
       tsconfig,
     });

package/src/compiler/internal/sharedHostHelpers.ts

@@ -2,6 +2,50 @@ import path from "node:path";
 
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
 
+/**
+ * Environment channel carrying the JSON-encoded tsgo argv ttsc forwards to a
+ * native sidecar. Mirrors `driver.TsgoArgsEnv` on the Go side; see
+ * `runBuild.ts::createNativeTsgoArgs` for why the payload is not a CLI flag.
+ */
+export const TSGO_ARGS_ENV = "TTSC_TSGO_ARGS";
+
+/**
+ * Drop a forwarded-tsgo payload this invocation did not publish itself.
+ *
+ * Every sidecar env starts from `process.env`, so a ttsc that is itself running
+ * inside a plugin sidecar — `@ttsc/lint` evaluating a config file through
+ * `ttsx`, for instance — would otherwise hand the outer run's `--strict` to its
+ * own sidecars, and `driver.LoadProgram` would apply it. The forwarded argv is
+ * per-invocation state the spawning host owns, the same rule
+ * `TTSC_PLUGIN_CONFIG_DIR` already follows. A caller that named the variable
+ * explicitly keeps it.
+ */
+export function clearInheritedTsgoArgs(
+  env: NodeJS.ProcessEnv,
+  callerEnv: NodeJS.ProcessEnv | undefined,
+): void {
+  if (callerEnv?.[TSGO_ARGS_ENV] === undefined) {
+    delete env[TSGO_ARGS_ENV];
+  }
+}
+
+/**
+ * The `{ ...process.env, ...callerEnv }` a child process inherits, minus a
+ * forwarded-tsgo payload this lane never published.
+ *
+ * Use it at every spawn whose child can reach `driver.LoadProgram` — the
+ * `api-compile` / `api-transform` hosts, and the plugin loader, whose `ttsx`
+ * descriptor evaluation compiles a project of its own. One rule at every site
+ * beats four sites each reasoning about whether the variable could be present.
+ */
+export function inheritedSidecarEnv(
+  callerEnv: NodeJS.ProcessEnv | undefined,
+): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...process.env, ...callerEnv };
+  clearInheritedTsgoArgs(env, callerEnv);
+  return env;
+}
+
 /**
  * Resolve the caller-declared plugin config anchor to an absolute path, or
  * `undefined` when the caller did not declare one.

package/src/compiler/internal/startResidentTransform.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 
+import { resolveNodeBinary } from "../../internal/resolveNodeBinary";
 import { loadProjectPlugins } from "../../plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
@@ -9,6 +10,8 @@ import { resolveBinary } from "./resolveBinary";
 import { resolveTsgo } from "./resolveTsgo";
 import {
   assertSharedHostCompatibility,
+  clearInheritedTsgoArgs,
+  inheritedSidecarEnv,
   linkedTransformPlugins,
   resolvePluginConfigDir,
   selectSharedHostPlugin,
@@ -52,7 +55,7 @@ export function startResidentTransform(
     cacheDir: context.cacheDir ?? context.env?.TTSC_CACHE_DIR,
     cwd,
     entries: context.plugins,
-    env: { ...process.env, ...context.env },
+    env: inheritedSidecarEnv(context.env),
     pluginConfigDir: context.pluginConfigDir,
     projectRoot: context.projectRoot,
     tsconfig: project.path,
@@ -79,7 +82,7 @@ export function startResidentTransform(
     ],
     binary: host.binary,
     cwd: project.root,
-    env: residentEnv(context, tsgoBinary, loaded.nativePlugins),
+    env: residentEnv(context, project.root, tsgoBinary, loaded.nativePlugins),
   });
   return { process: resident, projectRoot: project.root };
 }
@@ -95,13 +98,13 @@ export function startResidentTransform(
  */
 function residentEnv(
   context: ITtscCompilerContext,
+  projectRoot: string,
   tsgoBinary: string,
   nativePlugins: readonly ITtscLoadedNativePlugin[],
 ): NodeJS.ProcessEnv {
   const pluginConfigDir = resolvePluginConfigDir(context);
   const env: NodeJS.ProcessEnv = {
     ...process.env,
-    TTSC_NODE_BINARY: process.env.TTSC_NODE_BINARY ?? process.execPath,
     ...(pluginConfigDir === undefined
       ? {}
       : { TTSC_PLUGIN_CONFIG_DIR: pluginConfigDir }),
@@ -111,6 +114,9 @@ function residentEnv(
       path.join(__dirname, "..", "..", "launcher", "ttsx.js"),
     ...context.env,
   };
+  const node = resolveNodeBinary(env, projectRoot);
+  if (node === undefined) delete env.TTSC_NODE_BINARY;
+  else env.TTSC_NODE_BINARY = node;
   // The anchor is per-invocation state owned by this host: when this run
   // declared none (and the caller's env does not name one), drop any value
   // inherited from an ancestor ttsc process so a nested build never
@@ -121,6 +127,9 @@ function residentEnv(
   ) {
     delete env.TTSC_PLUGIN_CONFIG_DIR;
   }
+  // This lane forwards no tsgo argv of its own, so anything inherited belongs
+  // to an outer ttsc run and must not reach the resident sidecar.
+  clearInheritedTsgoArgs(env, context.env);
   const linked = linkedTransformPlugins(nativePlugins);
   if (linked.length !== 0) {
     env.TTSC_LINKED_PLUGINS_JSON = serializeNativePlugins(linked);