ttsc 0.26.1 → 0.27.0

package/src/launcher/internal/prepareExecution.ts

@@ -10,8 +10,6 @@ import { createFilesystemPathIdentityContext } from "../../internal/projectInput
 import type { TtscCommonOptions } from "../../structures/internal/TtscCommonOptions";
 import { type OwningModuleOptions, projectModuleOptions } from "./runtimeHooks";
 
-/** Subdirectory name that isolates concurrent ttsx processes by PID. */
-const PROCESS_CACHE_KEY = String(process.pid);
 /**
  * Maximum number of ancestor directories above the project root that the
  * virtual filesystem overlay mirrors. Three levels covers the common monorepo
@@ -32,12 +30,15 @@ export function prepareExecution(
   options: TtscCommonOptions & {
     cacheDir?: string;
     project?: string;
+    /** Internal cache key for more than one checked entry in this process. */
+    runtimeCacheKey?: string;
   } = {},
 ): {
   cleanupDir: string;
   emitDir: string;
   emittedFiles?: readonly string[];
   entryFile: string;
+  entrySource: string;
   moduleOptions: OwningModuleOptions;
   projectRoot: string;
   rootDir: string;
@@ -57,7 +58,6 @@ export function prepareExecution(
   const context = createProjectContext(
     cwd,
     path.resolve(cwd, entryFile),
-    entry,
     options,
   );
   try {
@@ -75,6 +75,7 @@ export function prepareExecution(
       emitDir: context.emitDir,
       emittedFiles: context.emittedFiles ?? undefined,
       entryFile: emittedEntry,
+      entrySource: entry,
       moduleOptions: context.moduleOptions,
       projectRoot: context.root,
       rootDir: context.runtimeRootDir,
@@ -148,16 +149,26 @@ function resolveEntrySpelling(cwd: string, entryFile: string): string {
   return identities.resolve(path.resolve(cwd, entryFile)).path;
 }
 
+/**
+ * Directory-safe identity for one prepared runtime. Direct `ttsx` retains its
+ * historical PID directory; the public preload supplies a distinct key for
+ * every late TypeScript root so one preparation cannot erase another's emit.
+ */
+function resolveRuntimeCacheKey(runtimeCacheKey: string | undefined): string {
+  const key = runtimeCacheKey ?? String(process.pid);
+  if (!/^[A-Za-z0-9._-]+$/.test(key) || key === "." || key === "..") {
+    throw new Error(`ttsx: invalid runtime cache key ${JSON.stringify(key)}`);
+  }
+  return key;
+}
+
 /**
  * @param discoveryFile - The entry as the user named it. Project discovery
  *   walks up from here, so it must not be retargeted through a symlink.
- * @param entry - The entry in its physical spelling, which is what the emit
- *   layout and the runtime hooks both speak.
  */
 function createProjectContext(
   cwd: string,
   discoveryFile: string,
-  entry: string,
   options: NonNullable<Parameters<typeof prepareExecution>[1]>,
 ) {
   const project = readProjectConfig(
@@ -172,21 +183,30 @@ function createProjectContext(
   const tsconfig = project.path;
   const root = project.root;
   const explicitCacheDir = resolveCacheDir(cwd, options.cacheDir);
-  const cacheDir =
+  const cacheDirSpelling =
     explicitCacheDir ??
     path.join(root, "node_modules", ".cache", "ttsc", "ttsx");
-  const processDir = path.join(cacheDir, "project", PROCESS_CACHE_KEY);
-  const virtualRoot = path.join(processDir, "fs");
+  const runtimeCacheKey = resolveRuntimeCacheKey(options.runtimeCacheKey);
   // Resolved once: it now costs a realpath (and, for a missing directory on
   // Windows, a case-sensitivity probe) rather than a string join.
-  const runtimeRootDir = resolveRuntimeSourceRoot(project, entry);
+  const runtimeRootDir = resolveRuntimeSourceRoot(project);
+  fs.mkdirSync(cacheDirSpelling, { recursive: true });
+  // Pin the cache parent before deriving a generation path. Descriptors run
+  // after this point and may retarget a caller-controlled symlink or junction;
+  // every later runtime write and recursive cleanup must remain below the
+  // physical parent selected here.
+  const cacheDir =
+    createFilesystemPathIdentityContext().resolve(cacheDirSpelling).path;
+  const processDir = path.join(cacheDir, "project", runtimeCacheKey);
+  const virtualRoot = path.join(processDir, "fs");
   return {
     project,
     tsconfig,
     root,
     cacheDir,
+    runtimeCacheKey,
     processDir,
-    pluginCacheDir: explicitCacheDir,
+    pluginCacheDir: explicitCacheDir === undefined ? undefined : cacheDir,
     virtualRoot,
     emitDir: project.compilerOptions.outDir
       ? virtualPath(virtualRoot, project.compilerOptions.outDir)
@@ -217,6 +237,16 @@ function createProjectContext(
  * The source-tree root the emit mirrors, in the same physical spelling as the
  * entry it will be compared against.
  *
+ * Undeclared, the root is the project's own directory, because that is the one
+ * tsgo uses: with a config file in play `GetCommonSourceDirectory` answers that
+ * file's directory and never computes a common directory of the input files.
+ * The entry's directory is not that root — it is only the same directory when
+ * the entry happens to sit beside the tsconfig, which is precisely why a
+ * `src/`-shaped project mislaid its emit here (issue #1172) while a flat one
+ * worked. `runtimeHooks.ts::resolveDependencySourceRoot` and
+ * `watchTopology.ts::inferPerSourceCompilerOutputs` already model the same
+ * rule, and `runBuild.ts::pinnedRootDirArgs` pins it for tsgo itself.
+ *
  * Resolving it is the other half of `resolveEntrySpelling`, and skipping it
  * leaves the comparison mixed rather than merely imprecise. `project.root`
  * arrives through plain `fs.realpathSync`, which resolves reparse points but
@@ -227,22 +257,25 @@ function createProjectContext(
  * way the gate reads an in-project entry as outside its own root, pays a second
  * whole build for it, and publishes a wider root than the project has.
  *
- * `path.dirname(entry)` is already physical, so only the declared branch needs
- * the pass.
+ * The pass costs nothing in agreement with the root tsgo was pinned to, which
+ * stays unresolved on purpose so it matches the spelling tsgo gives the input
+ * file names it compares against it. Only the prefix differs between the two;
+ * each side strips its own, so the relative path below the root — the part that
+ * decides where the emit lands and where the lookup reads — is identical.
  */
 function resolveRuntimeSourceRoot(
   project: ReturnType<typeof readProjectConfig>,
-  entry: string,
 ): string {
   const rootDir = project.compilerOptions.rootDir;
-  if (typeof rootDir !== "string") {
-    return path.dirname(entry);
-  }
   const identities = createFilesystemPathIdentityContext({
     throwOnRealpathError: false,
   });
   return identities.resolve(
-    path.isAbsolute(rootDir) ? rootDir : path.resolve(project.root, rootDir),
+    typeof rootDir !== "string"
+      ? project.root
+      : path.isAbsolute(rootDir)
+        ? rootDir
+        : path.resolve(project.root, rootDir),
   ).path;
 }
 
@@ -265,6 +298,13 @@ function buildProject(
     cacheDir: context.pluginCacheDir,
     outDir: context.emitDir,
     passthrough: options.passthrough,
+    // `context.emitDir` is ttsx's own temp directory, not an output the project
+    // asked for, and tsgo demands an explicit `rootDir` (TS5011) as soon as any
+    // `outDir` is in play. Pinning the root tsgo would infer keeps a check-only
+    // project runnable without moving its emit (issue #1172); a project that
+    // declares `rootDir` is left exactly as it is, which is also the root
+    // `resolveRuntimeSourceRoot` published above.
+    pinInferredRootDir: true,
     // Emit a source map on the transient entry emit (a PID-isolated temp dir,
     // never the consumer's `outDir`) so the serve path can inline it under the
     // source URL. Routed as a dedicated build option, not a forwarded tsgo
@@ -345,7 +385,7 @@ function buildEntryProject(
   const rootDir = commonAncestorDirectory(path.dirname(entry), context.root);
   const tsconfig = path.join(
     context.root,
-    `.ttsx-entry.${PROCESS_CACHE_KEY}.tsconfig.json`,
+    `.ttsx-entry.${context.runtimeCacheKey}.tsconfig.json`,
   );
   fs.writeFileSync(
     tsconfig,
@@ -414,8 +454,8 @@ function buildEntryProject(
       fs.rmSync(tsconfig, { force: true });
     } catch {
       // Best effort: a leftover synthesized tsconfig must not mask a build
-      // failure, and it is PID-scoped so it can never be mistaken for a real
-      // project config.
+      // failure, and it is runtime-scoped so it can never be mistaken for a
+      // real project config.
     }
   }
 }
@@ -559,6 +599,9 @@ function isDirectorySymlinkTarget(realEntry: string): boolean {
  */
 function collectLinkDirectories(projectRoot: string): string[] {
   const out: string[] = [];
+  const identities = createFilesystemPathIdentityContext({
+    throwOnRealpathError: false,
+  });
   let current = projectRoot;
   for (let depth = 0; depth <= MAX_VIRTUAL_PARENT_DEPTH; depth += 1) {
     out.push(current);
@@ -570,7 +613,7 @@ function collectLinkDirectories(projectRoot: string): string[] {
       break;
     }
     const parent = path.dirname(current);
-    if (parent === current || isUnsafeVirtualParent(parent)) {
+    if (parent === current || isUnsafeVirtualParent(parent, identities)) {
       break;
     }
     current = parent;
@@ -578,10 +621,19 @@ function collectLinkDirectories(projectRoot: string): string[] {
   return out.reverse();
 }
 
-function isUnsafeVirtualParent(directory: string): boolean {
-  const resolved = path.resolve(directory);
-  const root = path.parse(resolved).root;
-  return resolved === root || resolved === path.resolve(os.tmpdir());
+/**
+ * Whether mirroring `directory` would reach a filesystem or temporary root.
+ * Identity comparison is required on Windows, where `os.tmpdir()` can carry an
+ * 8.3 component while a project created below it is returned in long spelling.
+ */
+function isUnsafeVirtualParent(
+  directory: string,
+  identities: ReturnType<typeof createFilesystemPathIdentityContext>,
+): boolean {
+  const resolved = identities.resolve(directory);
+  const root = identities.resolve(path.parse(resolved.path).root);
+  const temporaryRoot = identities.resolve(os.tmpdir());
+  return resolved.key === root.key || resolved.key === temporaryRoot.key;
 }
 
 /**

package/src/launcher/internal/runTtsc.ts

@@ -17,7 +17,7 @@ import {
   parseFlags,
 } from "../../flags/parser";
 import { resolveFlagSpec } from "../../flags/schema";
-import { assertSafeExplicitCacheDirectory } from "../../internal/assertSafeExplicitCacheDirectory";
+import { resolveSafeCacheCleanupTargets } from "../../internal/resolveSafeCacheCleanupTargets";
 import {
   isPathWithin,
   legacyGlobalCacheTargets,
@@ -27,6 +27,7 @@ import {
 import type { ITtscProjectInputSnapshot } from "../../structures/internal/ITtscProjectInputSnapshot";
 import type { TtscBuildOptions } from "../../structures/internal/TtscBuildOptions";
 import type { TtscSingleFileEmitOptions } from "../../structures/internal/TtscSingleFileEmitOptions";
+import { assertNoSolutionBuild } from "./assertNoSolutionBuild";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { resolveCacheDir } from "./resolveCacheDir";
 import { resolveSingleFileOutput } from "./singleFileOutput";
@@ -206,9 +207,6 @@ function runClean(argv: readonly string[]): number {
   const explicitCacheDir = options.cacheDir
     ? path.resolve(cwd, options.cacheDir)
     : undefined;
-  if (explicitCacheDir !== undefined) {
-    assertSafeExplicitCacheDirectory(projectRoot, explicitCacheDir);
-  }
   const targets = explicitCacheDir
     ? // Explicit `ttsc clean --cache-dir X`: the user names X as the cache to
       // remove for this command, so remove it wholesale plus the legacy
@@ -222,11 +220,19 @@ function runClean(argv: readonly string[]): number {
       // possibly-shared root is never deleted) plus the pre-0.17 machine-global
       // cache so upgraders reclaim that disk.
       [...resolveCleanTargets(projectRoot), ...legacyGlobalCacheTargets()];
+  // Check the complete deletion set before removing the first directory. An
+  // environment-selected TTSC_GO_CACHE_DIR and a legacy-global cache can be as
+  // destructive as an explicit --cache-dir when either equals or contains the
+  // project through its lexical spelling or a filesystem alias.
+  const safeTargets = resolveSafeCacheCleanupTargets(projectRoot, targets);
   const removed: string[] = [];
-  for (const target of targets) {
-    if (!fs.existsSync(target)) continue;
-    fs.rmSync(target, { recursive: true, force: true });
-    removed.push(target);
+  const visited = new Set<string>();
+  for (const target of safeTargets) {
+    if (visited.has(target.path)) continue;
+    visited.add(target.path);
+    if (!target.exists || !fs.existsSync(target.path)) continue;
+    fs.rmSync(target.path, { recursive: true, force: true });
+    removed.push(target.requestedPath);
   }
   if (removed.length === 0) {
     process.stdout.write(
@@ -268,24 +274,28 @@ function runCachePaths(argv: readonly string[]): number {
   const cacheDir = resolveCacheDir(cwd, options.cacheDir);
   const projectRoot = resolveCleanProjectRoot(cwd, options.tsconfig);
   const paths = resolveSourceBuildCachePaths(projectRoot, cacheDir);
-  // The minimal directory set a CI cache step must persist. The Go build cache
-  // is folded in only when it lives outside the ttsc cache root (an explicit
-  // GOCACHE / TTSC_GO_CACHE_DIR); by default it nests under `root`.
+  // Legacy combined roots retained for JSON compatibility. `requiredRoots`
+  // identifies the compiled binaries that skip cold builds;
+  // `acceleratorRoots` separately identifies the optional Go object cache.
   const cacheableRoots = [
     paths.root,
     ...(isPathWithin(paths.goBuildRoot, paths.root) ? [] : [paths.goBuildRoot]),
   ];
+  const requiredRoots = [paths.pluginRoot];
+  const acceleratorRoots = [paths.goBuildRoot];
   if (options.json) {
     process.stdout.write(
       `${JSON.stringify(
         {
           cacheRoot: paths.root,
+          acceleratorRoots,
           cacheableRoots,
           cwd,
           goBuildCacheRoot: paths.goBuildRoot,
           goBuildCacheSource: paths.goBuildRootSource,
           pluginCacheRoot: paths.pluginRoot,
           projectRoot,
+          requiredRoots,
         },
         null,
         2,
@@ -300,8 +310,10 @@ function runCachePaths(argv: readonly string[]): number {
       `  plugin binaries  ${paths.pluginRoot}`,
       `  go build cache   ${paths.goBuildRoot} (${paths.goBuildRootSource})`,
       "",
-      "Persist these between CI jobs to skip cold plugin rebuilds:",
-      ...cacheableRoots.map((root) => `  ${root}`),
+      "Persist this required cache to skip cold plugin rebuilds:",
+      ...requiredRoots.map((root) => `  ${root}`),
+      "Optionally persist this Go object accelerator for future cache misses:",
+      ...acceleratorRoots.map((root) => `  ${root}`),
       "",
     ].join("\n"),
   );
@@ -441,6 +453,7 @@ function parseBuildArgs(argv: readonly string[]) {
     isPositional: looksLikeInputFile,
     subcommand: "build",
   });
+  assertNoSolutionBuild(result, "ttsc:");
   // Defaults: pinned by the previous hand-parser. `quiet` defaults true,
   // `--verbose` flips it to false; `emit` defaults `undefined` so the resolved
   // project controls ordinary build mode. `runCompatibleBuild` applies the

package/src/launcher/internal/runTtscserver.ts

@@ -9,11 +9,13 @@ import { readProjectConfig } from "../../compiler/internal/project/readProjectCo
 import { resolveBinary } from "../../compiler/internal/resolveBinary";
 import { resolveTsgo } from "../../compiler/internal/resolveTsgo";
 import { outputText, spawnNative } from "../../compiler/internal/spawnNative";
+import { createCanonicalTempDirectory } from "../../internal/createCanonicalTempDirectory";
 import {
   type ProjectInputPathIdentityContext,
   createProjectInputPathIdentityContext,
   resolveProjectInputPath,
 } from "../../internal/projectInputPathIdentity";
+import { resolveNodeBinary } from "../../internal/resolveNodeBinary";
 import {
   hasProjectPluginEntries,
   loadProjectPlugins,
@@ -127,6 +129,9 @@ function resolveTtscserverEnv(argv: readonly string[]): TtscserverEnvironment {
   }
   const context = resolveLspExecutionContext(argv);
   const env = lspSidecarEnvironment({
+    cwd:
+      context.projectContext?.logicalProjectRoot ??
+      path.resolve(optionValue(argv, "--cwd") ?? process.cwd()),
     pluginConfigOrigin: context.projectContext?.pluginConfigOrigin,
     tsgoBinary: context.tsgoBinary,
   });
@@ -170,7 +175,7 @@ export function materializeLSPPluginManifest(manifest: unknown): {
   dispose(): void;
   path: string;
 } {
-  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-lsp-"));
+  const directory = createCanonicalTempDirectory("ttsc-lsp-");
   const location = path.join(directory, "plugins.json");
   try {
     fs.writeFileSync(location, JSON.stringify(manifest), {
@@ -194,17 +199,20 @@ export function materializeLSPPluginManifest(manifest: unknown): {
 }
 
 function lspSidecarEnvironment(options: {
+  cwd: string;
   pluginConfigOrigin: string | undefined;
   tsgoBinary: string;
 }): NodeJS.ProcessEnv {
   const env: NodeJS.ProcessEnv = {
     ...process.env,
-    TTSC_NODE_BINARY: process.env.TTSC_NODE_BINARY ?? process.execPath,
     TTSC_TSGO_BINARY: options.tsgoBinary,
     TTSC_TTSX_BINARY:
       process.env.TTSC_TTSX_BINARY ??
       path.join(__dirname, "..", "..", "launcher", "ttsx.js"),
   };
+  const node = resolveNodeBinary(env, options.cwd);
+  if (node === undefined) delete env.TTSC_NODE_BINARY;
+  else env.TTSC_NODE_BINARY = node;
   if (options.pluginConfigOrigin === undefined) {
     delete env.TTSC_PLUGIN_CONFIG_DIR;
   } else {
@@ -318,7 +326,13 @@ function loadLSPProjectPlugins(
         pluginConfigDir: pluginConfigOrigin,
         tsconfig: project.identity.logicalConfigPath,
       })
-    : { nativePlugins: [], project };
+    : {
+        hostInputHashes: {},
+        hostInputRealpaths: {},
+        hostInputs: [...project.configPaths],
+        nativePlugins: [],
+        project,
+      };
 }
 
 function captureInitialLSPProjectInputs(options: {
@@ -355,6 +369,7 @@ function captureInitialLSPProjectInputs(options: {
       );
     }
     const env = lspSidecarEnvironment({
+      cwd: options.project.root,
       pluginConfigOrigin: options.pluginConfigOrigin,
       tsgoBinary: options.tsgoBinary,
     });

package/src/launcher/internal/runTtsx.ts

@@ -11,6 +11,7 @@ import {
   parseFlags,
 } from "../../flags/parser";
 import { resolveFlagSpec } from "../../flags/schema";
+import { assertNoSolutionBuild } from "./assertNoSolutionBuild";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { prepareExecution } from "./prepareExecution";
 import { resolveCacheDir } from "./resolveCacheDir";
@@ -130,6 +131,7 @@ function parseCLI(argv: readonly string[]) {
     isPositional: looksLikeEntryFile,
     subcommand: "ttsx",
   });
+  assertNoSolutionBuild(result, "ttsx:");
 
   const entry = result.positional.find(looksLikeEntryFile);
   if (entry === undefined) {
@@ -276,6 +278,8 @@ function runPreparedEntry(
         depCacheDir,
         emitDir: execution.emitDir,
         emittedFiles: execution.emittedFiles,
+        entryFile: execution.entryFile,
+        entrySource: execution.entrySource,
         moduleOptions: execution.moduleOptions,
         projectRoot: execution.projectRoot,
         rootDir: execution.rootDir,