ttsc 0.21.0 → 0.23.0

package/src/launcher/internal/runTtsx.ts

@@ -299,20 +299,52 @@ function runPreparedEntry(
       sourceEntry,
       ...parsed.passthrough,
     ];
+    const evaluatorBoundary = readEvaluatorBoundary(process.env);
+    const runtimeEnv: NodeJS.ProcessEnv = {
+      ...process.env,
+      NODE_OPTIONS: appendNodeOption(
+        process.env.NODE_OPTIONS,
+        `--require ${JSON.stringify(path.join(__dirname, "runtimeHookPreload.js"))}`,
+      ),
+      TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? tsgo,
+      TTSX_RUNTIME_MANIFEST: manifestPath,
+    };
+    delete runtimeEnv[TTSC_TTSX_EVALUATOR_DEADLINE_ENV];
+    delete runtimeEnv[TTSC_TTSX_EVALUATOR_MAX_BUFFER_ENV];
+    delete runtimeEnv[TTSC_TTSX_EVALUATOR_STATUS_FD_ENV];
+
     const result = spawnSync(process.execPath, args, {
       cwd,
-      env: {
-        ...process.env,
-        NODE_OPTIONS: appendNodeOption(
-          process.env.NODE_OPTIONS,
-          `--require ${JSON.stringify(path.join(__dirname, "runtimeHookPreload.js"))}`,
-        ),
-        TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? tsgo,
-        TTSX_RUNTIME_MANIFEST: manifestPath,
-      },
-      stdio: "inherit",
+      env: runtimeEnv,
+      ...(evaluatorBoundary
+        ? {
+            killSignal: "SIGKILL" as const,
+            timeout: Math.max(
+              1,
+              Math.min(
+                MAX_CHILD_PROCESS_TIMEOUT_MS,
+                evaluatorBoundary.deadlineMs - Date.now(),
+              ),
+            ),
+            maxBuffer: evaluatorBoundary.maxBuffer,
+            stdio: ["inherit", "pipe", "pipe"] as const,
+          }
+        : { stdio: "inherit" as const }),
       windowsHide: true,
     });
+    const nestedCode = (result.error as NodeJS.ErrnoException | undefined)
+      ?.code;
+    if (
+      evaluatorBoundary &&
+      (nestedCode === "ETIMEDOUT" || nestedCode === "ENOBUFS")
+    ) {
+      reportEvaluatorFailure(evaluatorBoundary.statusFd, nestedCode);
+      return 1;
+    }
+    if (evaluatorBoundary) {
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.stderr) process.stderr.write(result.stderr);
+    }
     if (result.error) {
       process.stderr.write(`${result.error.message}\n`);
       return 1;
@@ -323,6 +355,51 @@ function runPreparedEntry(
   }
 }
 
+interface TtsxEvaluatorBoundary {
+  deadlineMs: number;
+  maxBuffer: number;
+  statusFd: number;
+}
+
+const TTSC_TTSX_EVALUATOR_DEADLINE_ENV = "TTSC_TTSX_EVALUATOR_DEADLINE_MS";
+const TTSC_TTSX_EVALUATOR_MAX_BUFFER_ENV =
+  "TTSC_TTSX_EVALUATOR_MAX_BUFFER_BYTES";
+const TTSC_TTSX_EVALUATOR_STATUS_FD_ENV = "TTSC_TTSX_EVALUATOR_STATUS_FD";
+const TTSC_TTSX_EVALUATOR_STATUS_FD = 3;
+const MAX_CHILD_PROCESS_TIMEOUT_MS = 2_147_483_647;
+
+function readEvaluatorBoundary(
+  env: NodeJS.ProcessEnv,
+): TtsxEvaluatorBoundary | undefined {
+  const deadlineMs = Number(env[TTSC_TTSX_EVALUATOR_DEADLINE_ENV]);
+  const maxBuffer = Number(env[TTSC_TTSX_EVALUATOR_MAX_BUFFER_ENV]);
+  const statusFd = Number(env[TTSC_TTSX_EVALUATOR_STATUS_FD_ENV]);
+  if (
+    !Number.isSafeInteger(deadlineMs) ||
+    deadlineMs <= 0 ||
+    !Number.isSafeInteger(maxBuffer) ||
+    maxBuffer <= 0 ||
+    maxBuffer > MAX_CHILD_PROCESS_TIMEOUT_MS ||
+    statusFd !== TTSC_TTSX_EVALUATOR_STATUS_FD
+  ) {
+    return undefined;
+  }
+  return { deadlineMs, maxBuffer, statusFd };
+}
+
+function reportEvaluatorFailure(
+  statusFd: number,
+  code: "ENOBUFS" | "ETIMEDOUT",
+): void {
+  try {
+    fs.writeSync(statusFd, code);
+  } catch {
+    // The boundary is an internal parent/child protocol. If a standalone ttsx
+    // caller supplied only the environment variables, preserve the ordinary
+    // non-zero bounded-process result instead of replacing it with an fd error.
+  }
+}
+
 function removeRuntimeOutput(directory: string): void {
   try {
     fs.rmSync(directory, { force: true, recursive: true });

package/src/launcher/internal/runtimeHooks.ts

@@ -15,6 +15,10 @@ import { resolveEmittedJavaScript } from "../../compiler/internal/resolveEmitted
 import { resolveTsgo } from "../../compiler/internal/resolveTsgo";
 import { runBuild } from "../../compiler/internal/runBuild";
 import { outputText, spawnNative } from "../../compiler/internal/spawnNative";
+import {
+  type FilesystemPathIdentityContext,
+  createFilesystemPathIdentityContext,
+} from "../../internal/projectInputPathIdentity";
 import { inlineServedSourceMap } from "./servedSourceMap";
 
 /**
@@ -1143,23 +1147,19 @@ function serveEntryEmit(real: string): ServedSource | null {
  * Both sides are normalized to native separators first: a manifest `rootDir`
  * arrives slash-normalized from the synthesized tsconfig (`C:/` on Windows)
  * while `real` paths are native, and a raw prefix comparison across the two
- * forms silently never matches. Windows paths also compare case-insensitively
- * (a lowercase `TEMP` yields a `c:`-rooted `rootDir` for the same volume the
- * real paths spell `C:`). Exported for direct exercise by the ttsx e2e suite —
- * spawned runs cannot pin the Windows normalization branches on CI.
+ * forms silently never matches. Filesystem identity preserves ordinary Windows
+ * aliases while keeping case-distinct paths under an opted-in directory
+ * separate. Exported for direct exercise by the ttsx e2e suite — spawned runs
+ * cannot pin both Windows case-semantics branches on CI.
  */
-export function isWithin(real: string, directory: string): boolean {
-  const fold = (value: string): string =>
-    process.platform === "win32"
-      ? path.normalize(value).toLowerCase()
-      : path.normalize(value);
-  const target = fold(real);
-  const dir = fold(directory);
-  if (target === dir) {
-    return true;
-  }
-  const prefix = dir.endsWith(path.sep) ? dir : dir + path.sep;
-  return target.startsWith(prefix);
+export function isWithin(
+  real: string,
+  directory: string,
+  identities: FilesystemPathIdentityContext = createFilesystemPathIdentityContext(
+    { throwOnRealpathError: false },
+  ),
+): boolean {
+  return identities.isWithin(directory, real);
 }
 
 /**

package/src/launcher/internal/singleFileOutput.ts

@@ -0,0 +1,133 @@
+import path from "node:path";
+
+import { readProjectConfig } from "../../compiler/internal/project/readProjectConfig";
+import { resolveFlagSpec } from "../../flags/schema";
+
+/**
+ * Resolves the only file that positional `ttsc <source>` can materialize in the
+ * user's tree.
+ *
+ * The compiler itself emits into a private temporary directory. The launcher
+ * then copies one transformed JavaScript file to this path, so project-mode
+ * declaration, map, build-info, outFile, and broad outDir products are not
+ * positional outputs.
+ */
+export function resolveSingleFileOutput(options: {
+  cliOutDir?: string;
+  cwd: string;
+  file: string;
+  passthrough?: readonly string[];
+  tsconfig?: string;
+}): string {
+  const project = readProjectSettings(options);
+  const extension = singleFileJavaScriptExtension(
+    options.file,
+    passthroughStringOption(options.passthrough, "--jsx") ?? project?.jsx,
+  );
+  const jsBasename =
+    path.basename(options.file).replace(/\.(?:[cm]?tsx?|jsx)$/i, "") +
+    extension;
+
+  if (options.cliOutDir) {
+    const relative = path.relative(options.cwd, options.file);
+    const jsRelative =
+      relative.slice(0, relative.length - path.extname(relative).length) +
+      extension;
+    return path.resolve(options.cwd, options.cliOutDir, jsRelative);
+  }
+
+  if (project?.outDir !== undefined) {
+    const fromRoot = path.relative(project.rootDir, options.file);
+    if (fromRoot !== "" && !isOutsideSingleFileLayout(fromRoot)) {
+      const jsRelative =
+        fromRoot.slice(0, fromRoot.length - path.extname(fromRoot).length) +
+        extension;
+      return path.resolve(project.outDir, jsRelative);
+    }
+    return path.resolve(project.outDir, jsBasename);
+  }
+
+  return options.file.replace(/\.(?:[cm]?tsx?|jsx)$/i, extension);
+}
+
+function readProjectSettings(options: {
+  cwd: string;
+  file: string;
+  tsconfig?: string;
+}): { jsx?: string; outDir?: string; rootDir: string } | null {
+  try {
+    const project = readProjectConfig({
+      cwd: options.cwd,
+      file: options.file,
+      tsconfig: options.tsconfig,
+    });
+    const outDir = project.compilerOptions.outDir;
+    const rawRoot = project.compilerOptions.rootDir;
+    const rootDir =
+      typeof rawRoot === "string" && rawRoot.length !== 0
+        ? path.isAbsolute(rawRoot)
+          ? rawRoot
+          : path.resolve(project.root, rawRoot)
+        : project.root;
+    const rawJsx = project.compilerOptions.jsx;
+    return {
+      jsx:
+        typeof rawJsx === "string" && rawJsx.length !== 0
+          ? rawJsx.toLowerCase()
+          : undefined,
+      outDir:
+        typeof outDir === "string" && outDir.length !== 0 ? outDir : undefined,
+      rootDir,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function isOutsideSingleFileLayout(relative: string): boolean {
+  return (
+    relative === ".." ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relative)
+  );
+}
+
+function singleFileJavaScriptExtension(
+  file: string,
+  jsx: string | undefined,
+): string {
+  switch (path.extname(file).toLowerCase()) {
+    case ".mts":
+      return ".mjs";
+    case ".cts":
+      return ".cjs";
+    case ".tsx":
+    case ".jsx":
+      return jsx === "preserve" ? ".jsx" : ".js";
+    default:
+      return ".js";
+  }
+}
+
+function passthroughStringOption(
+  tokens: readonly string[] | undefined,
+  name: string,
+): string | undefined {
+  let value: string | undefined;
+  for (let index = 0; index < (tokens?.length ?? 0); index++) {
+    const token = tokens?.[index];
+    if (
+      token === undefined ||
+      token.includes("=") ||
+      resolveFlagSpec(token)?.name !== resolveFlagSpec(name)?.name
+    ) {
+      continue;
+    }
+    const next = tokens?.[index + 1];
+    if (next !== undefined) {
+      value = next.toLowerCase();
+      index++;
+    }
+  }
+  return value;
+}