ttsc 0.26.2 → 0.27.0

package/shim/compiler/incremental.go

@@ -1,13 +1,20 @@
 // gen_shims:hand-maintained
 //
-// Reference-graph parts of tsgo's own incremental engine (`tsc --incremental`
-// semantics), linked from internal/execute/incremental so ttsc's transform
-// envelopes can carry the same language-semantic input bound the compiler
-// itself uses for invalidation: per-file direct resolved references and the
-// files that contribute to the global scope.
+// Parts of tsgo's own incremental engine (`tsc --incremental` semantics),
+// exposed from internal/execute/incremental for the two things a ttsc host
+// needs from it:
+//
+//   - the reference graph, so transform envelopes can carry the same
+//     language-semantic input bound the compiler itself uses for invalidation:
+//     per-file direct resolved references and the files that contribute to the
+//     global scope;
+//   - the build-information emit, so a host that constructs its Program
+//     in-process still writes the `.tsbuildinfo` an `incremental` or
+//     `composite` project asked for.
 package compiler
 
 import (
+  "context"
   _ "unsafe"
 
   innerast "github.com/microsoft/typescript-go/internal/ast"
@@ -15,11 +22,41 @@ import (
   innercompiler "github.com/microsoft/typescript-go/internal/compiler"
   "github.com/microsoft/typescript-go/internal/tspath"
 
-  // The linknamed symbols below live in the incremental package; the blank
-  // import compiles it into every shim consumer so the references resolve.
-  _ "github.com/microsoft/typescript-go/internal/execute/incremental"
+  // Imported for EmitFreshWithBuildInfo below, and for the linknamed symbols
+  // further down: compiling the package into every shim consumer is what makes
+  // those references resolve.
+  "github.com/microsoft/typescript-go/internal/execute/incremental"
 )
 
+// EmitFreshWithBuildInfo runs a full emit through tsgo's own incremental
+// program, so an `incremental` or `composite` project gets the `.tsbuildinfo`
+// tsgo would have written, in the exact format and location
+// `outputpaths.GetBuildInfoFileName` resolves from the compiler options.
+//
+// This is the emit half of `tsc.go::performIncrementalCompilation`, which the
+// tsgo CLI takes whenever `CompilerOptions.IsIncremental()`. A host that builds
+// its Program in-process (ttsc's driver, and therefore every plugin sidecar
+// emitting through it) never reaches that CLI path, so without this the build
+// information is silently dropped even though the options parsed cleanly.
+//
+// "Fresh" is the load-bearing word: no previous snapshot is supplied, so
+// `programToSnapshot` marks every file changed and this emits the whole program
+// exactly as `Program.Emit` does, then writes the build info. A ttsc plugin's
+// output is not a pure function of the source text a build info records — it
+// also depends on the plugin binary, its config file, and its contributors —
+// so reusing a previous snapshot to skip a file would serve stale transformed
+// output. Producing the record is sound; consuming it needs plugin identity in
+// the invalidation key first.
+func EmitFreshWithBuildInfo(ctx context.Context, program *Program, options EmitOptions) *EmitResult {
+  incrementalProgram := incremental.NewProgram(
+    program,
+    nil,
+    incremental.CreateHost(program.Host()),
+    false,
+  )
+  return incrementalProgram.Emit(ctx, options)
+}
+
 //go:linkname incrementalGetReferencedFiles github.com/microsoft/typescript-go/internal/execute/incremental.getReferencedFiles
 func incrementalGetReferencedFiles(program *innercompiler.Program, file *innerast.SourceFile) *collections.Set[tspath.Path]
 

package/src/TtscCompiler.ts

@@ -6,7 +6,10 @@ import { resolveProjectConfig } from "./compiler/internal/project/resolveProject
 import { resolveBinary } from "./compiler/internal/resolveBinary";
 import { createProcessDiagnostic } from "./compiler/internal/runBuild";
 import { transformProjectInMemory } from "./compiler/internal/transformProjectInMemory";
-import { assertSafeExplicitCacheDirectory } from "./internal/assertSafeExplicitCacheDirectory";
+import {
+  type SafeCacheCleanupTarget,
+  resolveSafeCacheCleanupTargets,
+} from "./internal/resolveSafeCacheCleanupTargets";
 import { resolveCleanTargets } from "./plugin/internal/buildSourcePlugin";
 import { loadProjectPlugins } from "./plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "./structures/ITtscCompilerContext";
@@ -86,15 +89,16 @@ export class TtscCompiler {
   /**
    * Remove compiled cache artifacts for this compiler instance.
    *
-   * Removes the resolved cache root (which holds both the plugin binaries and,
-   * when ttsc-owned, the Go build cache), a ttsc-owned Go build cache that
-   * lives outside that root (`TTSC_GO_CACHE_DIR`), and the two legacy
-   * project-local caches. A user-provided `GOCACHE` is never removed. The cache
+   * Removes an explicit `cacheDir` wholesale. Otherwise removes the plugin
+   * binary subdirectory, a safely identified ttsc-owned Go build cache
+   * (including an external `TTSC_GO_CACHE_DIR`), and the two legacy
+   * project-local caches. A user-provided `GOCACHE` is never removed. Every
+   * resolved deletion target is validated before the first removal. The cache
    * location comes from this instance's `cacheDir` and environment
    * (`TTSC_CACHE_DIR` / `TTSC_GO_CACHE_DIR`), defaulting to
-   * `<workspaceRoot>/node_modules/.cache/ttsc`. An explicit cache directory
-   * that equals or contains the project, or names a filesystem root, is
-   * rejected before any directory is removed.
+   * `<workspaceRoot>/node_modules/.cache/ttsc`. Any resolved cache target that
+   * equals or contains the project, or names a filesystem root, is rejected
+   * before any directory is removed.
    *
    * @returns Cache directories that were removed.
    */
@@ -105,31 +109,35 @@ export class TtscCompiler {
       path.join(projectRoot, ".ttsc"),
     ];
     const explicitCacheDir = this.resolveCacheDir();
+    let targets: string[];
     if (explicitCacheDir !== undefined) {
-      assertSafeExplicitCacheDirectory(projectRoot, explicitCacheDir);
       // An explicit constructor `cacheDir` names the cache directory for this
       // instance — exactly like `ttsc clean --cache-dir X` on the CLI — so
       // remove it wholesale plus the legacy project-local caches. This keeps
       // the programmatic and CLI clean contracts identical for an explicit
       // cache dir.
-      return removeExistingDirectories([explicitCacheDir, ...legacyTargets]);
-    }
-    // Default / `context.env.TTSC_CACHE_DIR`: resolve the cache root and the Go
-    // build cache (`TTSC_GO_CACHE_DIR`) from this instance's effective
-    // environment — the same `{ ...process.env, ...context.env }` that
-    // prepare()/compile()/transform() build with — then remove only the
-    // ttsc-owned subdirectories, so a possibly-shared root is never deleted and
-    // a user-provided `GOCACHE` is never touched. Using the effective env (not
-    // ambient `process.env`) makes clean() remove exactly the artifacts this
-    // instance owns, including a `TTSC_GO_CACHE_DIR` supplied only in
-    // `context.env`.
-    return removeExistingDirectories(
-      resolveCleanTargets(
+      targets = [explicitCacheDir, ...legacyTargets];
+    } else {
+      // Default / `context.env.TTSC_CACHE_DIR`: resolve the cache root and the Go
+      // build cache (`TTSC_GO_CACHE_DIR`) from this instance's effective
+      // environment — the same `{ ...process.env, ...context.env }` that
+      // prepare()/compile()/transform() build with — then remove only the
+      // ttsc-owned subdirectories, so a possibly-shared root is never deleted and
+      // a user-provided `GOCACHE` is never touched. Using the effective env (not
+      // ambient `process.env`) makes clean() remove exactly the artifacts this
+      // instance owns, including a `TTSC_GO_CACHE_DIR` supplied only in
+      // `context.env`.
+      targets = resolveCleanTargets(
         projectRoot,
         this.resolvePluginCacheDir(),
         this.resolveEffectiveEnv(),
-      ),
-    );
+      );
+    }
+    // Validate the complete deletion set before removing the first directory.
+    // This includes an environment-selected TTSC_GO_CACHE_DIR and project-local
+    // legacy locations, not only an explicit constructor cacheDir.
+    const safeTargets = resolveSafeCacheCleanupTargets(projectRoot, targets);
+    return removeExistingDirectories(safeTargets);
   }
 
   /**
@@ -234,24 +242,29 @@ export class TtscCompiler {
    * The effective environment for this instance's source-plugin builds and
    * clean targets: `context.env` merged over `process.env`, matching the
    * documented {@link ITtscCompilerContext.env} contract that child compiler,
-   * native-plugin, and native-host processes already receive. Returned as a
-   * fresh object so callers never mutate the shared `process.env`; when no
-   * `context.env` was supplied this is a plain copy of `process.env`, so CLI /
-   * default behavior is unchanged.
+   * native-plugin, native-host, and isolated descriptor processes already
+   * receive. Returned as a fresh object so callers never mutate the shared
+   * `process.env`; when no `context.env` was supplied this is a plain copy of
+   * `process.env`, so CLI / default behavior is unchanged.
    */
   private resolveEffectiveEnv(): NodeJS.ProcessEnv {
     return { ...process.env, ...this.context.env };
   }
 }
 
-function removeExistingDirectories(directories: readonly string[]): string[] {
+function removeExistingDirectories(
+  directories: readonly SafeCacheCleanupTarget[],
+): string[] {
   const removed: string[] = [];
-  for (const directory of [...new Set(directories)]) {
-    if (!fs.existsSync(directory)) {
+  const visited = new Set<string>();
+  for (const directory of directories) {
+    if (visited.has(directory.path)) continue;
+    visited.add(directory.path);
+    if (!directory.exists || !fs.existsSync(directory.path)) {
       continue;
     }
-    fs.rmSync(directory, { recursive: true, force: true });
-    removed.push(directory);
+    fs.rmSync(directory.path, { recursive: true, force: true });
+    removed.push(directory.requestedPath);
   }
   return removed;
 }
@@ -265,6 +278,9 @@ interface ProjectTransformation {
   dependencies?: Record<string, string[]>;
   dependenciesComplete?: string[];
   graph?: ITtscCompilerTransformation.IReferenceGraph;
+  hostInputHashes?: Record<string, string | null>;
+  hostInputRealpaths?: Record<string, string | null>;
+  hostInputs?: string[];
   result: TtscBuildResult;
   typescript: Record<string, string>;
   volatile?: string[];
@@ -382,6 +398,9 @@ function toCompilerTransformation(
     dependencies,
     dependenciesComplete,
     graph,
+    hostInputHashes,
+    hostInputRealpaths,
+    hostInputs,
     result,
     typescript,
     volatile,
@@ -390,6 +409,9 @@ function toCompilerTransformation(
     ...(dependencies === undefined ? {} : { dependencies }),
     ...(dependenciesComplete === undefined ? {} : { dependenciesComplete }),
     ...(graph === undefined ? {} : { graph }),
+    ...(hostInputHashes === undefined ? {} : { hostInputHashes }),
+    ...(hostInputRealpaths === undefined ? {} : { hostInputRealpaths }),
+    ...(hostInputs === undefined ? {} : { hostInputs }),
     ...(volatile === undefined ? {} : { volatile }),
   };
   if (result.status === 0 && !hasErrorDiagnostics(result.diagnostics)) {

package/src/compiler/internal/captureProcessOutput.ts

@@ -1,7 +1,8 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
+import { createCanonicalTempDirectory } from "../../internal/createCanonicalTempDirectory";
+
 export interface CapturedProcessOutput {
   /** Close the descriptors and remove the backing files. */
   dispose(): void;
@@ -32,7 +33,7 @@ export interface CapturedProcessOutput {
  * bytes.
  */
 export function captureProcessOutput(): CapturedProcessOutput {
-  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-spawn-"));
+  const directory = createCanonicalTempDirectory("ttsc-spawn-");
   const stdoutPath = path.join(directory, "stdout");
   const stderrPath = path.join(directory, "stderr");
   const stdoutFd = fs.openSync(stdoutPath, "w+");

package/src/compiler/internal/compileProjectInMemory.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 { hasProjectPluginEntries } from "../../plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
 import type { ITtscCompilerDiagnostic } from "../../structures/ITtscCompilerDiagnostic";
@@ -11,6 +11,7 @@ import { buildNativeCompiler } from "./buildNativeCompiler";
 import { isOutsideRelativePath, packageRootDir } from "./paths";
 import { readProjectConfig } from "./project/readProjectConfig";
 import { runBuild } from "./runBuild";
+import { inheritedSidecarEnv } from "./sharedHostHelpers";
 import { outputText, spawnNative } from "./spawnNative";
 
 /**
@@ -50,7 +51,7 @@ export function compileProjectInMemory(options: ITtscCompilerContext): {
     ["api-compile", "--cwd", project.root, "--tsconfig", tsconfig],
     {
       cwd: project.root,
-      env: { ...process.env, ...options.env },
+      env: inheritedSidecarEnv(options.env),
     },
   );
   if (res.error) {
@@ -110,7 +111,7 @@ function compileProjectWithPlugins(
   output: Record<string, string>;
   result: TtscBuildResult;
 } {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-api-output-"));
+  const tempRoot = createCanonicalTempDirectory("ttsc-api-output-");
   const tempOutDir = path.join(tempRoot, "out");
   try {
     const result = runBuild({

package/src/compiler/internal/resolveEmittedJavaScript.ts

@@ -20,6 +20,8 @@ import { isOutsideRelativePath } from "./paths";
  * Returns `null` when no matching output file is found on disk.
  */
 export function resolveEmittedJavaScript(options: {
+  /** Skip trailing-stem recovery when exact source ownership is required. */
+  allowStemFallback?: boolean;
   /** Pre-computed list of emitted paths; when absent `outDir` is scanned. */
   emittedFiles?: readonly string[];
   outDir: string;
@@ -45,6 +47,10 @@ export function resolveEmittedJavaScript(options: {
     }
   }
 
+  if (options.allowStemFallback === false) {
+    return null;
+  }
+
   // Score the pre-computed emit list first (cheap). When it yields nothing —
   // because the list is incomplete (a native transform host such as typia emits
   // without printing the `--listEmittedFiles` lines) or because the emit landed

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,
@@ -101,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 {
@@ -198,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
@@ -391,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.
@@ -411,6 +435,7 @@ export class ResidentCheckWatchSession {
           "ttsc.check",
           timing,
           `ttsc check plugin ${plugin.name} time`,
+          tsgoArgs,
         );
       } else {
         const startedAt = process.hrtime.bigint();
@@ -420,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);
         }
@@ -506,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 = {
@@ -524,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")
@@ -534,7 +565,7 @@ export function planResidentCheckEntries(
         entryIndex,
         key:
           plugin.capabilities?.residentCheck === true
-            ? residentCheckProcessKey(plugin, args)
+            ? residentCheckProcessKey(plugin, args, tsgoArgs)
             : undefined,
         plugin,
       };
@@ -830,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) {
@@ -1126,6 +1157,7 @@ function buildWithNativeCompilerPlugins(
     "ttsc.build",
     timing,
     transformHostTimingLabel(plugins),
+    createNativeBuildTsgoArgs(execution, options),
   );
 }
 
@@ -1150,7 +1182,7 @@ function runTsgo(
     ],
     {
       cwd: execution.projectRoot,
-      env: mergeEnv(options.env),
+      env: mergeEnv(options.env, execution.projectRoot),
       encoding: "utf8",
     },
   );
@@ -1184,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) {
@@ -1401,15 +1433,23 @@ function createNativeBuildArgs(
       args.push("--quiet");
     }
   }
-  // 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.
-  args.push(
-    ...createNativeTsgoArgs(options, pinnedRootDirArgs(execution, 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>,
@@ -1440,7 +1480,6 @@ function createNativeCheckArgs(
   }
   args.push(...createNativeCheckThreadingArgs(options, plugin));
   args.push(...createNativeCheckDiagnosticsArgs(options, plugin));
-  args.push(...createNativeTsgoArgs(options));
   return args;
 }
 
@@ -1550,15 +1589,37 @@ 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,
   leading: readonly string[] = [],
-): 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.
@@ -1567,9 +1628,9 @@ function createNativeTsgoArgs(
     ...isolatedTsgoOutputArgs(options),
   ];
   if (passthrough.length === 0) {
-    return [];
+    return undefined;
   }
-  return ["--tsgo-args=" + JSON.stringify(passthrough)];
+  return JSON.stringify(passthrough);
 }
 
 function isolatedTsgoOutputArgs(options: TtscCommonOptions): string[] {
@@ -1678,6 +1739,7 @@ function runNativeCheckPlugins(
       "ttsc.check",
       timing,
       `ttsc check plugin ${plugin.name} time`,
+      createNativeTsgoArgs(options),
     );
     out = appendBuildOutput(out, result);
     if (result.status !== 0) {
@@ -1949,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);
@@ -2047,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,