ttsc 0.24.0 → 0.26.0

package/src/plugin/internal/buildSourcePlugin.ts

@@ -1,6 +1,7 @@
 import {
   type SpawnSyncOptionsWithStringEncoding,
   type SpawnSyncReturns,
+  type StdioOptions,
   spawnSync,
 } from "node:child_process";
 import crypto from "node:crypto";
@@ -10,6 +11,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { captureProcessOutput } from "../../compiler/internal/captureProcessOutput";
 import { findNearestGoMod } from "../../compiler/internal/paths";
 
 const GO_MOD_SEARCH_MAX_DEPTH = 3;
@@ -1646,7 +1648,6 @@ function readGoModInfo(
     cwd: dir,
     encoding: "utf8",
     env: goBuildEnv(goBinary, undefined, env),
-    maxBuffer: 1024 * 1024 * 16,
     windowsHide: true,
   });
   if (result.error) {
@@ -1737,7 +1738,6 @@ function runGoBuild(
     cwd,
     encoding: "utf8",
     env: goBuildEnv(goBinary, goBuildCacheRoot, env),
-    maxBuffer: 1024 * 1024 * 64,
     windowsHide: true,
   });
   if (result.error) {
@@ -1767,6 +1767,40 @@ export function spawnGoTool(
   goBinary: string,
   args: readonly string[],
   options: SpawnSyncOptionsWithStringEncoding,
+): SpawnSyncReturns<string> {
+  // The child's streams go to files rather than pipes, so no output ceiling
+  // applies: `spawnSync` only bounds what it must hold in this process's
+  // memory, and a `go build` that says a great deal is not a failure to invent
+  // a limit for. See `captureProcessOutput`.
+  const capture = captureProcessOutput();
+  const spawnOptions = {
+    ...options,
+    stdio: ["ignore", capture.stdoutFd, capture.stderrFd] as StdioOptions,
+  };
+  try {
+    const result = spawnGoToolProcess(goBinary, args, spawnOptions);
+    const stdout = capture.read("stdout", "utf8") as string;
+    const stderr = capture.read("stderr", "utf8") as string;
+    return {
+      ...result,
+      output: [null, stdout, stderr],
+      stderr,
+      stdout,
+    };
+  } finally {
+    capture.dispose();
+  }
+}
+
+/**
+ * Launch the Go tool, routing through cmd.exe only where Windows needs a
+ * wrapper. Output routing is the caller's concern; this owns process
+ * selection.
+ */
+function spawnGoToolProcess(
+  goBinary: string,
+  args: readonly string[],
+  options: SpawnSyncOptionsWithStringEncoding,
 ): SpawnSyncReturns<string> {
   if (process.platform !== "win32") {
     return spawnSync(goBinary, [...args], options);
@@ -2734,7 +2768,6 @@ function resolveGoBuildEnvironment(
         cwd,
         encoding: "utf8",
         env: goBuildEnv(goBinary, undefined, env),
-        maxBuffer: 1024 * 1024,
         windowsHide: true,
       },
     );

package/src/plugin/internal/descriptorProcessFailure.ts

@@ -1,50 +1,30 @@
-export const PLUGIN_DESCRIPTOR_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
-export const PLUGIN_DESCRIPTOR_TIMEOUT_MS = 60_000;
-export const PLUGIN_DESCRIPTOR_TEARDOWN_GRACE_MS = 5_000;
-export const PLUGIN_DESCRIPTOR_STATUS_FD = 3;
-export const PLUGIN_DESCRIPTOR_PROCESS_OPTIONS = Object.freeze({
-  killSignal: "SIGKILL" as const,
-  maxBuffer: PLUGIN_DESCRIPTOR_MAX_BUFFER_BYTES,
-  timeout: PLUGIN_DESCRIPTOR_TIMEOUT_MS + PLUGIN_DESCRIPTOR_TEARDOWN_GRACE_MS,
-});
+import fs from "node:fs";
 
 interface DescriptorProcessResult {
   error?: Error;
-  output?: readonly (string | null)[] | null;
   signal: NodeJS.Signals | null;
   status: number | null;
-  stderr: string | null | undefined;
-  stdout: string | null | undefined;
 }
 
 /**
  * Classify the ways the isolated TypeScript descriptor evaluator can stop.
  *
- * Node reports both timeout and max-buffer termination with the configured
- * signal, so the process error code must take precedence over the signal. The
- * evaluator uses `SIGKILL`: Node's synchronous process API otherwise keeps
- * waiting when a POSIX child handles the default `SIGTERM` without exiting.
+ * The loader writes the child's own output straight to this process's stderr,
+ * so a diagnostic has already reached the user by the time anything here runs.
+ * What is left to say is only how the process ended: it never launched,
+ * something outside killed it, or it exited non-zero after printing its own
+ * reason.
+ *
+ * Nothing is bounded here — not time, not output. Both were the compiler
+ * deciding, on numbers nobody chose for this machine, that a user's own
+ * descriptor had run too long or said too much. Neither is this process's
+ * memory to spend either, because the child's streams are no longer collected
+ * into it.
  */
 export function pluginDescriptorProcessFailure(
   result: DescriptorProcessResult,
   request: string,
 ): Error | undefined {
-  const code = (result.error as NodeJS.ErrnoException | undefined)?.code;
-  const nestedCode = result.output?.[PLUGIN_DESCRIPTOR_STATUS_FD]?.trim() ?? "";
-  if (code === "ETIMEDOUT" || nestedCode === "ETIMEDOUT") {
-    return new Error(
-      `ttsc: plugin descriptor "${request}" evaluation through ttsx timed out after ` +
-        `${PLUGIN_DESCRIPTOR_TIMEOUT_MS / 1_000} seconds. ` +
-        "Descriptor modules and factories must finish their setup within that window.",
-    );
-  }
-  if (code === "ENOBUFS" || nestedCode === "ENOBUFS") {
-    return new Error(
-      `ttsc: plugin descriptor "${request}" evaluation through ttsx exceeded the ` +
-        `${PLUGIN_DESCRIPTOR_MAX_BUFFER_BYTES / (1024 * 1024)} MiB process output limit. ` +
-        "Reduce stdout and stderr from the descriptor and its dependencies.",
-    );
-  }
   if (result.error) {
     return new Error(
       `ttsc: failed to launch ttsx for plugin descriptor "${request}": ${result.error.message}`,
@@ -56,45 +36,34 @@ export function pluginDescriptorProcessFailure(
     );
   }
   if (result.status !== 0) {
-    const reason = descriptorFailureReason(
-      hasText(result.stderr) ? result.stderr : result.stdout,
-    );
     return new Error(
-      `ttsc: plugin descriptor "${request}" evaluation through ttsx failed with exit code ${String(result.status)}` +
-        (reason === "" ? "" : "\n" + reason),
+      `ttsc: plugin descriptor "${request}" evaluation through ttsx failed with exit code ${String(result.status)}`,
     );
   }
   return undefined;
 }
 
 /**
- * Pass the semantic deadline and private status pipe through the `ttsx` wrapper
- * to the runtime child that actually executes the descriptor.
+ * Read the failure envelope the descriptor shim writes to its result file when
+ * it stops on an error it can name.
+ *
+ * This is the other half of classifying how the evaluation ended, which is why
+ * it lives beside {@link pluginDescriptorProcessFailure} rather than at the call
+ * site: the status says that it failed, and this says why.
+ *
+ * Only a well-formed envelope is honoured. A real descriptor never carries this
+ * key, and every other shape — an absent file, a shim that died before writing,
+ * a half-written result, a descriptor written before a later non-zero exit —
+ * leaves the process status to speak for itself.
  */
-export function pluginDescriptorBoundaryEnvironment(
-  now: number = Date.now(),
-): NodeJS.ProcessEnv {
-  return {
-    TTSC_TTSX_EVALUATOR_DEADLINE_MS: String(now + PLUGIN_DESCRIPTOR_TIMEOUT_MS),
-    TTSC_TTSX_EVALUATOR_MAX_BUFFER_BYTES: String(
-      PLUGIN_DESCRIPTOR_MAX_BUFFER_BYTES,
-    ),
-    TTSC_TTSX_EVALUATOR_STATUS_FD: String(PLUGIN_DESCRIPTOR_STATUS_FD),
-  };
-}
-
-function hasText(value: string | null | undefined): value is string {
-  return value !== null && value !== undefined && value.trim() !== "";
-}
-
-function descriptorFailureReason(stderr: string | null | undefined): string {
-  const bounded = (stderr ?? "").slice(-PLUGIN_DESCRIPTOR_REASON_MAX_CHARS);
-  const lines = bounded
-    .split(/\r?\n/)
-    .map((line) => line.trimEnd())
-    .filter((line) => line.trim() !== "");
-  return lines.slice(-PLUGIN_DESCRIPTOR_REASON_LINES).join("\n");
+export function pluginDescriptorFailureReason(outputPath: string): string {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(outputPath, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return "";
+    const message = (parsed as { __ttscLoaderError?: unknown })
+      .__ttscLoaderError;
+    return typeof message === "string" ? message.trim() : "";
+  } catch {
+    return "";
+  }
 }
-
-const PLUGIN_DESCRIPTOR_REASON_LINES = 5;
-const PLUGIN_DESCRIPTOR_REASON_MAX_CHARS = 8 * 1024;

package/src/plugin/internal/loadProjectPlugins.ts

@@ -16,10 +16,7 @@ import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoa
 import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
 import { buildSourcePlugin } from "./buildSourcePlugin";
 import {
-  PLUGIN_DESCRIPTOR_MAX_BUFFER_BYTES,
-  PLUGIN_DESCRIPTOR_PROCESS_OPTIONS,
-  PLUGIN_DESCRIPTOR_STATUS_FD,
-  pluginDescriptorBoundaryEnvironment,
+  pluginDescriptorFailureReason,
   pluginDescriptorProcessFailure,
 } from "./descriptorProcessFailure";
 
@@ -696,6 +693,50 @@ function requirePluginEntry(
 
 const TS_SOURCE_PATTERN = /\.(?:[cm]?ts|tsx)$/i;
 
+/**
+ * The descriptor shim's emitted source.
+ *
+ * Exported so a regression can inspect the same bytes ttsx executes. This
+ * template consumes its own escapes, so reading this file's text instead would
+ * check characters no consumer ever sees — and a dropped backslash turns an
+ * escape into the character it was escaping: a raw line terminator inside a
+ * string literal, which stops the shim parsing and takes every descriptor load
+ * with it. Its `@ttsc/lint` twin has carried that guard since the same defect
+ * shipped there.
+ */
+export const PLUGIN_DESCRIPTOR_SHIM_SOURCE = [
+  `// @ts-nocheck`,
+  `import { writeFileSync } from "node:fs";`,
+  `import { pathToFileURL } from "node:url";`,
+  // The import is inside the try, not above it. A descriptor that cannot be
+  // found, or whose module body throws, fails exactly where a descriptor
+  // whose factory throws does, and a caller deserves the same reason for
+  // both — "Cannot find module ./missing" is as actionable as anything the
+  // factory could have said.
+  `try {`,
+  `  const mod = await import(pathToFileURL(process.env.TTSC_PLUGIN_ENTRY).href);`,
+  `  const context = JSON.parse(process.env.TTSC_PLUGIN_CONTEXT);`,
+  `  const candidate = mod.createTtscPlugin ?? mod.default ?? mod.plugin ?? mod;`,
+  `  const descriptor =`,
+  `    typeof candidate === "function" ? candidate(context) : candidate;`,
+  `  writeFileSync(process.env.TTSC_PLUGIN_DESCRIPTOR_OUT, JSON.stringify(descriptor));`,
+  `} catch (error) {`,
+  // The stack streams to the user's stderr on its own. This puts the reason
+  // a caller can act on into the channel the parent already reads, so the
+  // failure is not reduced to a bare exit status.
+  // The escape is doubled on purpose: this template consumes one level, so
+  // `\\n` here is what puts the two-character escape into the emitted shim.
+  // A single `\n` would put a raw line terminator inside a string literal,
+  // and the shim would stop parsing — taking every descriptor load with it.
+  `  process.stderr.write((error instanceof Error && error.stack ? error.stack : String(error)) + "\\n");`,
+  `  try {`,
+  `    writeFileSync(process.env.TTSC_PLUGIN_DESCRIPTOR_OUT, JSON.stringify({ __ttscLoaderError: error instanceof Error ? error.message : String(error) }));`,
+  `  } catch {}`,
+  `  process.exit(1);`,
+  `}`,
+  ``,
+].join("\n");
+
 /**
  * Evaluate a `.ts` plugin descriptor entry in a child `ttsx` process and return
  * the descriptor it produces. A generated shim imports the entry, invokes its
@@ -735,21 +776,7 @@ function loadDescriptorViaTtsx(
       },
     }),
   );
-  fs.writeFileSync(
-    shim,
-    [
-      `// @ts-nocheck`,
-      `import { writeFileSync } from "node:fs";`,
-      `import { pathToFileURL } from "node:url";`,
-      `const mod = await import(pathToFileURL(process.env.TTSC_PLUGIN_ENTRY).href);`,
-      `const context = JSON.parse(process.env.TTSC_PLUGIN_CONTEXT);`,
-      `const candidate = mod.createTtscPlugin ?? mod.default ?? mod.plugin ?? mod;`,
-      `const descriptor =`,
-      `  typeof candidate === "function" ? candidate(context) : candidate;`,
-      `writeFileSync(process.env.TTSC_PLUGIN_DESCRIPTOR_OUT, JSON.stringify(descriptor));`,
-      ``,
-    ].join("\n"),
-  );
+  fs.writeFileSync(shim, PLUGIN_DESCRIPTOR_SHIM_SOURCE);
   try {
     const result = childProcess.spawnSync(node, [ttsx, "--no-plugins", shim], {
       cwd: context.projectRoot,
@@ -773,34 +800,30 @@ function loadDescriptorViaTtsx(
         TTSC_PLUGIN_DESCRIPTOR_LOAD: "1",
         TTSC_PLUGIN_DESCRIPTOR_OUT: out,
         TTSC_PLUGIN_ENTRY: request,
-        ...pluginDescriptorBoundaryEnvironment(),
       },
-      ...PLUGIN_DESCRIPTOR_PROCESS_OPTIONS,
-      stdio: [
-        "ignore",
-        "pipe",
-        "pipe",
-        ...Array.from(
-          { length: PLUGIN_DESCRIPTOR_STATUS_FD - 2 },
-          () => "pipe" as const,
-        ),
-      ],
+      // Both child streams are human output, and they go straight to this
+      // process's stderr as they are written. The descriptor itself travels
+      // through a file, so nothing here needs collecting — and collecting it
+      // only to replay it afterwards is what forced an invented output ceiling.
+      stdio: ["ignore", 2, 2],
       windowsHide: true,
     });
     const processFailure = pluginDescriptorProcessFailure(result, request);
-    if (processFailure) throw processFailure;
+    if (processFailure) {
+      // The descriptor's stack already reached the user's stderr as it ran.
+      // What it could not put there is a reason a caller can act on, so that
+      // arrives through the result file instead.
+      const reason = pluginDescriptorFailureReason(out);
+      throw reason === ""
+        ? processFailure
+        : new Error(`${processFailure.message}
+${reason}`);
+    }
     if (!fs.existsSync(out)) {
       throw new Error(
         `ttsc: plugin descriptor "${request}" evaluation through ttsx produced no descriptor output.`,
       );
     }
-    const outputSize = fs.statSync(out).size;
-    if (outputSize > PLUGIN_DESCRIPTOR_MAX_BUFFER_BYTES) {
-      throw new Error(
-        `ttsc: plugin descriptor "${request}" produced ${outputSize} bytes of JSON, ` +
-          `exceeding the ${PLUGIN_DESCRIPTOR_MAX_BUFFER_BYTES / (1024 * 1024)} MiB descriptor output limit.`,
-      );
-    }
     const text = fs.readFileSync(out, "utf8");
     try {
       return JSON.parse(text);
@@ -810,7 +833,7 @@ function loadDescriptorViaTtsx(
       );
     }
   } finally {
-    fs.rmSync(dir, { force: true, recursive: true });
+    removeEvaluationTempDir(dir);
   }
 }
 
@@ -1389,3 +1412,19 @@ function readTsgoVersion(projectRoot: string): string {
     return "unknown";
   }
 }
+
+/**
+ * Remove an evaluation temp directory without letting cleanup replace a result.
+ *
+ * This runs from a `finally`, so a throw here would surface instead of the
+ * evaluation's own outcome — and on Windows a grandchild that inherited a
+ * handle, or a scanner holding the file, can make removal fail. Leaving bytes
+ * in the system temp directory is by far the lesser outcome.
+ */
+function removeEvaluationTempDir(directory: string): void {
+  try {
+    fs.rmSync(directory, { force: true, recursive: true });
+  } catch {
+    // Best effort.
+  }
+}