ttsc 0.26.2 → 0.28.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,
@@ -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,

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);