ttsc 0.22.0 → 0.23.0

package/src/launcher/internal/runTtscserver.ts

@@ -8,7 +8,11 @@ import { createNativeProjectContextArgs } from "../../compiler/internal/project/
 import { readProjectConfig } from "../../compiler/internal/project/readProjectConfig";
 import { resolveBinary } from "../../compiler/internal/resolveBinary";
 import { resolveTsgo } from "../../compiler/internal/resolveTsgo";
-import { resolveProjectInputPath } from "../../internal/projectInputPathIdentity";
+import {
+  type ProjectInputPathIdentityContext,
+  createProjectInputPathIdentityContext,
+  resolveProjectInputPath,
+} from "../../internal/projectInputPathIdentity";
 import {
   hasProjectPluginEntries,
   loadProjectPlugins,
@@ -313,8 +317,7 @@ function loadLSPProjectPlugins(
         binary: resolveBinary() ?? "",
         cwd,
         pluginConfigDir: pluginConfigOrigin,
-        projectRoot: project.root,
-        tsconfig: project.path,
+        tsconfig: project.identity.logicalConfigPath,
       })
     : { nativePlugins: [], project };
 }
@@ -472,9 +475,8 @@ export function fingerprintInitialLSPProjectInputSnapshot(
   const reloadDirectoryDigests: Record<string, string> = {};
   const reloadFileDigests: Record<string, string> = {};
   for (const directory of snapshot.reloadDirectories ?? []) {
-    reloadDirectoryDigests[directory] = lspProjectInputDirectoryDigest(
-      realLSPProjectInputPath(directory),
-    );
+    reloadDirectoryDigests[directory] =
+      lspProjectInputReloadDirectoryDigest(directory);
   }
   for (const file of snapshot.reloadFiles ?? []) {
     reloadFileDigests[file] = lspProjectInputFileDigest(
@@ -495,7 +497,7 @@ export function initialLSPProjectInputSnapshotIsCurrent(
     (snapshot.reloadDirectories ?? []).every(
       (directory) =>
         snapshot.reloadDirectoryDigests[directory] ===
-        lspProjectInputDirectoryDigest(realLSPProjectInputPath(directory)),
+        lspProjectInputReloadDirectoryDigest(directory),
     ) &&
     (snapshot.reloadFiles ?? []).every(
       (file) =>
@@ -524,16 +526,84 @@ function lspSelectionSignature(
   });
 }
 
-function lspProjectInputDirectoryDigest(location: string): string {
+function lspProjectInputReloadDirectoryDigest(location: string): string {
+  const identities = createProjectInputPathIdentityContext();
+  const identity = lspProjectInputPhysicalPathIdentity(location, identities);
+  return createHash("sha256")
+    .update(
+      Buffer.concat([
+        Buffer.from("directory\0"),
+        identity,
+        Buffer.from([0]),
+        Buffer.from(
+          lspProjectInputDirectoryTopologyDigest(
+            process.platform === "win32"
+              ? identities.resolve(location).path
+              : identity,
+          ),
+        ),
+      ]),
+    )
+    .digest("hex");
+}
+
+function lspProjectInputPhysicalPathIdentity(
+  location: string,
+  identities: ProjectInputPathIdentityContext,
+): Buffer {
+  if (process.platform === "win32") {
+    return Buffer.from(
+      identities.resolve(location).path.replaceAll("\\", "/"),
+      "utf8",
+    );
+  }
+  let existing = path.resolve(location);
+  const missing: Buffer[] = [];
+  while (true) {
+    try {
+      const realpath = fs.realpathSync.native ?? fs.realpathSync;
+      let physical = realpath(Buffer.from(existing), {
+        encoding: "buffer",
+      });
+      for (const segment of missing) {
+        physical = Buffer.concat([
+          physical,
+          physical.at(-1) === 0x2f ? Buffer.alloc(0) : Buffer.from("/"),
+          segment,
+        ]);
+      }
+      return physical;
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code !== "ENOENT" &&
+        error.code !== "ENOTDIR"
+      ) {
+        throw error;
+      }
+      const parent = path.dirname(existing);
+      if (parent === existing) return Buffer.from(existing);
+      missing.unshift(Buffer.from(path.basename(existing)));
+      existing = parent;
+    }
+  }
+}
+
+function lspProjectInputDirectoryTopologyDigest(
+  location: string | Buffer,
+): string {
   const entries: Buffer[] = [];
   try {
     if (process.platform === "win32") {
-      for (const entry of fs.readdirSync(location, { withFileTypes: true })) {
+      const directory =
+        typeof location === "string" ? location : location.toString("utf8");
+      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
         let target = Buffer.alloc(0);
         if (entry.isSymbolicLink()) {
           try {
             target = Buffer.from(
-              fs.readlinkSync(path.join(location, entry.name)),
+              fs.readlinkSync(path.join(directory, entry.name)),
               "utf8",
             );
           } catch {
@@ -558,7 +628,7 @@ function lspProjectInputDirectoryDigest(location: string): string {
           try {
             target = fs.readlinkSync(
               Buffer.concat([
-                Buffer.from(location),
+                Buffer.isBuffer(location) ? location : Buffer.from(location),
                 Buffer.from(path.sep),
                 entry.name,
               ]),

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);
 }
 
 /**