ttsc 0.23.0 → 0.25.0

package/src/compiler/internal/compileProjectInMemory.ts

@@ -1,4 +1,3 @@
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -12,6 +11,7 @@ import { buildNativeCompiler } from "./buildNativeCompiler";
 import { isOutsideRelativePath, packageRootDir } from "./paths";
 import { readProjectConfig } from "./project/readProjectConfig";
 import { runBuild } from "./runBuild";
+import { outputText, spawnNative } from "./spawnNative";
 
 /**
  * Compile a project and capture emitted files without writing to the project
@@ -45,15 +45,12 @@ export function compileProjectInMemory(options: ITtscCompilerContext): {
     cacheDir: options.cacheDir ?? options.env?.TTSC_CACHE_DIR,
     packageRoot: packageRootDir(),
   });
-  const res = spawnSync(
+  const res = spawnNative(
     binary,
     ["api-compile", "--cwd", project.root, "--tsconfig", tsconfig],
     {
       cwd: project.root,
-      encoding: "utf8",
       env: { ...process.env, ...options.env },
-      maxBuffer: 1024 * 1024 * 256,
-      windowsHide: true,
     },
   );
   if (res.error) {
@@ -62,14 +59,17 @@ export function compileProjectInMemory(options: ITtscCompilerContext): {
     );
   }
 
-  const output = parseNativeCompileOutput(res.stdout, res.stderr);
+  const output = parseNativeCompileOutput(
+    outputText(res.stdout),
+    outputText(res.stderr),
+  );
   return {
     output: output.output,
     result: {
       diagnostics: output.diagnostics,
       status: res.status ?? 1,
       stdout: "",
-      stderr: res.stderr,
+      stderr: outputText(res.stderr),
     },
   };
 }

package/src/compiler/internal/residentCheckProcess.ts

@@ -2,7 +2,6 @@ import { type ChildProcess, spawn } from "node:child_process";
 import { type Interface, createInterface } from "node:readline";
 
 import type { TtscBuildResult } from "../../structures/internal/TtscBuildResult";
-import { normalizeRequestTimeoutMs } from "./residentTransformProcess";
 
 const STDERR_TAIL_LIMIT = 64 * 1024;
 const REPLY_ECHO_LIMIT = 200;
@@ -13,7 +12,6 @@ export interface ResidentCheckProcessOptions {
   binary: string;
   cwd: string;
   env: NodeJS.ProcessEnv;
-  requestTimeoutMs?: number;
 }
 
 export interface ResidentCheckRequest {
@@ -36,7 +34,6 @@ export type ResidentCheckResult = TtscBuildResult & {
 type PendingRequest = {
   reject(reason: Error): void;
   resolve(result: ResidentCheckResult): void;
-  timer: NodeJS.Timeout;
 };
 
 /**
@@ -51,12 +48,10 @@ export class ResidentCheckProcess {
   private readonly child: ChildProcess;
   private readonly pending: PendingRequest[] = [];
   private readonly reader: Interface;
-  private readonly requestTimeoutMs: number;
   private failure: Error | undefined;
   private stderr = "";
 
   public constructor(options: ResidentCheckProcessOptions) {
-    this.requestTimeoutMs = normalizeRequestTimeoutMs(options.requestTimeoutMs);
     this.child = spawn(options.binary, [...options.args], {
       cwd: options.cwd,
       env: options.env,
@@ -98,21 +93,7 @@ export class ResidentCheckProcess {
       return Promise.reject(asError(error));
     }
     return new Promise<ResidentCheckResult>((resolve, reject) => {
-      const pending: PendingRequest = {
-        reject,
-        resolve,
-        timer: setTimeout(() => {
-          const detail = stderrSuffix(this.stderr);
-          const timeout = new Error(
-            `ttsc: resident check request timed out after ${String(
-              this.requestTimeoutMs,
-            )} ms${detail}`,
-          );
-          this.settle(pending, timeout);
-          this.fail(timeout);
-        }, this.requestTimeoutMs),
-      };
-      pending.timer.unref();
+      const pending: PendingRequest = { reject, resolve };
       this.pending.push(pending);
       try {
         stdin.write(line, (error) => {
@@ -161,7 +142,6 @@ export class ResidentCheckProcess {
     const index = this.pending.indexOf(pending);
     if (index === -1) return;
     this.pending.splice(index, 1);
-    clearTimeout(pending.timer);
     if (result instanceof Error) pending.reject(result);
     else pending.resolve(result);
   }

package/src/compiler/internal/residentTransformProcess.ts

@@ -7,12 +7,6 @@ const STDERR_TAIL_LIMIT = 64 * 1024;
 /** Cap on how much of an offending line an error message echoes back. */
 const REPLY_ECHO_LIMIT = 200;
 
-/** Default deadline for one request to the resident transform host. */
-const DEFAULT_REQUEST_TIMEOUT_MS = 300_000;
-
-/** Node clamps timers beyond this signed 32-bit millisecond duration. */
-const MAX_TIMER_MS = 2_147_483_647;
-
 /** Allow a cooperative host a short shutdown window before forcing it down. */
 const TERMINATION_GRACE_MS = 1_000;
 
@@ -32,8 +26,6 @@ export interface ResidentTransformProcessOptions {
   binary: string;
   cwd?: string;
   env?: NodeJS.ProcessEnv;
-  /** Maximum time one request may wait for the resident host's reply. */
-  requestTimeoutMs?: number;
 }
 
 /** Per-request lifecycle controls for a resident transform host. */
@@ -49,7 +41,6 @@ interface PendingRequest {
   resolve: (reply: Record<string, unknown>) => void;
   settled: boolean;
   signal?: AbortSignal;
-  timer: NodeJS.Timeout;
 }
 
 /**
@@ -70,12 +61,10 @@ export class ResidentTransformProcess {
   private readonly child: ChildProcess;
   private readonly reader: Interface;
   private readonly pending: PendingRequest[] = [];
-  private readonly requestTimeoutMs: number;
   private stderr = "";
   private failure: Error | undefined;
 
   public constructor(options: ResidentTransformProcessOptions) {
-    this.requestTimeoutMs = normalizeRequestTimeoutMs(options.requestTimeoutMs);
     // Default stdio is "pipe" for stdin/stdout/stderr, which is exactly what the
     // line protocol needs; spelling it out as a string[] would not narrow to
     // StdioOptions, so it is left implicit.
@@ -153,9 +142,7 @@ export class ResidentTransformProcess {
         resolve,
         settled: false,
         signal: options.signal,
-        timer: setTimeout(() => this.timeout(pending), this.requestTimeoutMs),
       };
-      pending.timer.unref();
       if (options.signal !== undefined) {
         pending.abort = () => this.cancel(pending, options.signal!);
         options.signal.addEventListener("abort", pending.abort, { once: true });
@@ -285,7 +272,6 @@ export class ResidentTransformProcess {
     pending.settled = true;
     const index = this.pending.indexOf(pending);
     if (index !== -1) this.pending.splice(index, 1);
-    clearTimeout(pending.timer);
     if (pending.signal !== undefined && pending.abort !== undefined) {
       pending.signal.removeEventListener("abort", pending.abort);
     }
@@ -293,23 +279,6 @@ export class ResidentTransformProcess {
     else pending.resolve(result);
   }
 
-  private timeout(pending: PendingRequest): void {
-    if (pending.settled) return;
-    const timeout = new Error(
-      `ttsc: resident transform request timed out after ${String(
-        this.requestTimeoutMs,
-      )} ms${stderrSuffix(this.stderr)}`,
-    );
-    this.settlePending(pending, timeout);
-    this.fail(
-      new Error(
-        `ttsc: resident transform host retired after another request timed out${stderrSuffix(
-          this.stderr,
-        )}`,
-      ),
-    );
-  }
-
   private cancel(pending: PendingRequest, signal: AbortSignal): void {
     if (pending.settled) return;
     this.settlePending(pending, cancelledError(signal));
@@ -362,17 +331,6 @@ export class ResidentTransformProcess {
   }
 }
 
-/** Validate and normalize the caller-visible resident request deadline. */
-export function normalizeRequestTimeoutMs(requestTimeoutMs?: number): number {
-  const value = requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-  if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_TIMER_MS) {
-    throw new TypeError(
-      `ttsc: requestTimeoutMs must be an integer between 1 and ${String(MAX_TIMER_MS)}`,
-    );
-  }
-  return value;
-}
-
 function cancelledError(signal: AbortSignal): Error {
   const error = new Error(
     `ttsc: resident transform request cancelled${abortDetail(signal)}`,

package/src/compiler/internal/spawnNative.ts

@@ -1,13 +1,22 @@
-import { spawnSync } from "node:child_process";
+import { type SpawnSyncReturns, spawnSync } from "node:child_process";
 import fs from "node:fs";
 
+import { captureProcessOutput } from "./captureProcessOutput";
+
 /**
  * Spawn a native binary (or a Node.js script when the path has a JS/TS
- * extension) with the given args and return the `spawnSync` result. Sets a
- * generous 256 MiB output buffer so large projects do not truncate.
+ * extension) and return its result with `stdout` and `stderr` as text.
+ *
+ * The child's streams are written to files rather than piped, and the files are
+ * read once it exits. `spawnSync` buffers a _piped_ stream in this process's
+ * memory and refuses to hold more than `maxBuffer` bytes, so a piped capture
+ * has to name a ceiling — and any ceiling is a number nobody chose for this
+ * machine, deciding that a large but legitimate compile said too much. A file
+ * has no such limit: the bytes never pass through this heap on their way out of
+ * the child, and how many there may be is the filesystem's business.
  *
- * When `options.encoding` is omitted it defaults to `"utf8"`. Pass an explicit
- * value when the caller needs a different encoding or raw `Buffer` output.
+ * When `options.encoding` is omitted it defaults to `"utf8"`. Pass `"buffer"`
+ * when the caller needs raw bytes.
  */
 export function spawnNative(
   binary: string,
@@ -15,24 +24,36 @@ export function spawnNative(
   options: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
-    encoding?: BufferEncoding;
+    encoding?: BufferEncoding | "buffer";
   },
-) {
+): SpawnSyncReturns<string | Buffer> {
   const viaNode = /\.(?:[cm]?js|ts)$/i.test(binary);
   if (!viaNode) {
     ensureExecutable(binary);
   }
-  return spawnSync(
-    viaNode ? process.execPath : binary,
-    viaNode ? [binary, ...args] : [...args],
-    {
-      cwd: options.cwd,
-      encoding: options.encoding ?? "utf8",
-      env: options.env,
-      maxBuffer: 1024 * 1024 * 256,
-      windowsHide: true,
-    },
-  );
+  const capture = captureProcessOutput();
+  try {
+    const result = spawnSync(
+      viaNode ? process.execPath : binary,
+      viaNode ? [binary, ...args] : [...args],
+      {
+        cwd: options.cwd,
+        env: options.env,
+        stdio: ["ignore", capture.stdoutFd, capture.stderrFd],
+        windowsHide: true,
+      },
+    );
+    const stdout = capture.read("stdout", options.encoding);
+    const stderr = capture.read("stderr", options.encoding);
+    return {
+      ...result,
+      output: [null, stdout, stderr],
+      stderr,
+      stdout,
+    } as SpawnSyncReturns<string | Buffer>;
+  } finally {
+    capture.dispose();
+  }
 }
 
 /**

package/src/compiler/internal/startResidentTransform.ts

@@ -4,10 +4,7 @@ import { loadProjectPlugins } from "../../plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
 import { readProjectConfig } from "./project/readProjectConfig";
-import {
-  ResidentTransformProcess,
-  normalizeRequestTimeoutMs,
-} from "./residentTransformProcess";
+import { ResidentTransformProcess } from "./residentTransformProcess";
 import { resolveBinary } from "./resolveBinary";
 import { resolveTsgo } from "./resolveTsgo";
 import {
@@ -26,11 +23,6 @@ export interface StartedResidentTransform {
   projectRoot: string;
 }
 
-/** Construction controls owned by the resident request client. */
-export interface StartResidentTransformOptions {
-  requestTimeoutMs?: number;
-}
-
 /**
  * Start a resident `serve` host for the configured project.
  *
@@ -48,9 +40,7 @@ export interface StartResidentTransformOptions {
  */
 export function startResidentTransform(
   context: ITtscCompilerContext,
-  options: StartResidentTransformOptions = {},
 ): StartedResidentTransform {
-  const requestTimeoutMs = normalizeRequestTimeoutMs(options.requestTimeoutMs);
   const cwd = path.resolve(context.cwd ?? process.cwd());
   const project = readProjectConfig({
     cwd,
@@ -90,7 +80,6 @@ export function startResidentTransform(
     binary: host.binary,
     cwd: project.root,
     env: residentEnv(context, tsgoBinary, loaded.nativePlugins),
-    requestTimeoutMs,
   });
   return { process: resident, projectRoot: project.root };
 }