ttsc 0.14.0-dev.20260529.2 → 0.14.0

package/src/flags/parser.ts

@@ -10,19 +10,14 @@
 //
 // The schema is the spec; behaviour at every layer boundary is determined by
 // the FlagSpec attributes, not by ad-hoc `if (arg === "--foo")` branches.
-
-import type {
-  AnySubcommand,
-  FlagSpec,
-  ValueValidator,
-} from "./schema";
+import type { AnySubcommand, FlagSpec, ValueValidator } from "./schema";
 import { FLAG_BY_NAME, flagsForSubcommand } from "./schema";
 
 /**
- * Per-subcommand parse result. `values` is keyed by the canonical flag
- * name (e.g. `"--singleThreaded"`); boolean flags resolve to `true`/`false`,
- * value flags to the parsed value type. Callers narrow with the helpers
- * below (`getBoolean`, `getString`, `getNumber`).
+ * Per-subcommand parse result. `values` is keyed by the canonical flag name
+ * (e.g. `"--singleThreaded"`); boolean flags resolve to `true`/`false`, value
+ * flags to the parsed value type. Callers narrow with the helpers below
+ * (`getBoolean`, `getString`, `getNumber`).
  */
 export interface ParseResult {
   /** Canonical flag name → resolved value. */
@@ -32,17 +27,15 @@ export interface ParseResult {
   /** Bare non-flag positional arguments, in original order. */
   readonly positional: readonly string[];
   /**
-   * Tokens that arrived after the `forwardAfterFirstPositional` sentinel.
-   * These are intended for the user's program (e.g. ttsx's entry-file argv);
-   * they are NOT forwarded to tsgo. Always empty when
-   * `forwardAfterFirstPositional` is false.
+   * Tokens that arrived after the `forwardAfterFirstPositional` sentinel. These
+   * are intended for the user's program (e.g. ttsx's entry-file argv); they are
+   * NOT forwarded to tsgo. Always empty when `forwardAfterFirstPositional` is
+   * false.
    */
   readonly tail: readonly string[];
 }
 
-/**
- * Options controlling a single `parseFlags` invocation.
- */
+/** Options controlling a single `parseFlags` invocation. */
 export interface ParseOptions {
   /** Which subcommand's flag subset to accept. */
   readonly subcommand: AnySubcommand;
@@ -54,24 +47,24 @@ export interface ParseOptions {
    */
   readonly errorPrefix: string;
   /**
-   * `true` to treat the FIRST positional token as a sentinel that switches
-   * the engine to "forward everything after" mode (ttsx's entry-file
-   * behaviour: tokens after the entry are runtime argv, not tsgo flags).
-   * The sentinel itself is still recorded as a positional argument.
+   * `true` to treat the FIRST positional token as a sentinel that switches the
+   * engine to "forward everything after" mode (ttsx's entry-file behaviour:
+   * tokens after the entry are runtime argv, not tsgo flags). The sentinel
+   * itself is still recorded as a positional argument.
    */
   readonly forwardAfterFirstPositional?: boolean;
   /**
-   * Optional `"--"` separator handling: when present in argv, every token
-   * after `--` is appended to `passthrough` as-is (ttsx already does this).
+   * Optional `"--"` separator handling: when present in argv, every token after
+   * `--` is appended to `passthrough` as-is (ttsx already does this).
    */
   readonly honorDoubleDashSeparator?: boolean;
 }
 
 /**
  * Parse `argv` according to FLAG_SCHEMA filtered by `subcommand`. Returns a
- * `ParseResult`. Throws `Error` (with the configured prefix) on invalid
- * input — unknown subcommand-only flag, missing required value, value that
- * fails its validator.
+ * `ParseResult`. Throws `Error` (with the configured prefix) on invalid input —
+ * unknown subcommand-only flag, missing required value, value that fails its
+ * validator.
  */
 export function parseFlags(opts: ParseOptions): ParseResult {
   const accepted = new Map<string, FlagSpec>();
@@ -103,7 +96,9 @@ export function parseFlags(opts: ParseOptions): ParseResult {
     }
   }
   const head: string[] = [
-    ...(remainder === null ? opts.argv : opts.argv.slice(0, indexOfSeparator(opts.argv))),
+    ...(remainder === null
+      ? opts.argv
+      : opts.argv.slice(0, indexOfSeparator(opts.argv))),
   ];
 
   let forwardingTail = false;
@@ -160,10 +155,7 @@ export function parseFlags(opts: ParseOptions): ParseResult {
 
     // Bare token: positional argument (file / entry / project path).
     positional.push(current);
-    if (
-      opts.forwardAfterFirstPositional === true &&
-      positional.length === 1
-    ) {
+    if (opts.forwardAfterFirstPositional === true && positional.length === 1) {
       forwardingTail = true;
     }
   }
@@ -179,9 +171,9 @@ export function parseFlags(opts: ParseOptions): ParseResult {
 }
 
 /**
- * Pull the value for `flag` from either `inlineValue` (`--flag=value`) or
- * the next argv token (`--flag value`), validate it per the schema, and
- * write it to the result map.
+ * Pull the value for `flag` from either `inlineValue` (`--flag=value`) or the
+ * next argv token (`--flag value`), validate it per the schema, and write it to
+ * the result map.
  */
 function consumeFlag(
   values: Map<string, string | boolean | number>,
@@ -226,7 +218,9 @@ function consumeFlag(
   }
 
   const raw =
-    inlineValue !== undefined ? inlineValue : takeValueToken(token, rest, errorPrefix);
+    inlineValue !== undefined
+      ? inlineValue
+      : takeValueToken(token, rest, errorPrefix);
   if (flag.validator === "positiveInt") {
     values.set(flag.name, validatePositiveInt(token, raw, errorPrefix));
     return;
@@ -235,13 +229,13 @@ function consumeFlag(
 }
 
 /**
- * Read the value token that follows `flag`. Throws if argv ends here OR if
- * the next token looks like another flag (`-` prefix). Without the
- * "looks like a flag" guard `ttsc --cwd --strict src/main.ts` would silently
- * consume `--strict` as the value of `--cwd`, leaving `--strict` lost and
- * `cwd` set to a junk path. Mirrors the symmetric guard already in
- * `forwardKnownButUnaccepted` (RC-1 fairness — the two value-resolution
- * paths must agree on what counts as "a missing value").
+ * Read the value token that follows `flag`. Throws if argv ends here OR if the
+ * next token looks like another flag (`-` prefix). Without the "looks like a
+ * flag" guard `ttsc --cwd --strict src/main.ts` would silently consume
+ * `--strict` as the value of `--cwd`, leaving `--strict` lost and `cwd` set to
+ * a junk path. Mirrors the symmetric guard already in
+ * `forwardKnownButUnaccepted` (RC-1 fairness — the two value-resolution paths
+ * must agree on what counts as "a missing value").
  */
 function takeValueToken(
   flag: string,
@@ -265,9 +259,9 @@ function takeValueToken(
 }
 
 /**
- * Parse a CLI boolean literal — `true`/`false` only (case-sensitive to
- * match tsgo's parser). Returns `undefined` for any other token so the
- * caller knows to throw or treat as a non-value.
+ * Parse a CLI boolean literal — `true`/`false` only (case-sensitive to match
+ * tsgo's parser). Returns `undefined` for any other token so the caller knows
+ * to throw or treat as a non-value.
  */
 function parseBooleanLiteral(raw: string): boolean | undefined {
   if (raw === "true") return true;
@@ -277,8 +271,8 @@ function parseBooleanLiteral(raw: string): boolean | undefined {
 
 /**
  * Validate a `positiveInt` value. Mirrors tsgo's `--checkers minValue:1`
- * constraint so a typo fails loudly at the launcher rather than reaching
- * tsgo with an invalid argument.
+ * constraint so a typo fails loudly at the launcher rather than reaching tsgo
+ * with an invalid argument.
  */
 function validatePositiveInt(
   flag: string,
@@ -295,10 +289,10 @@ function validatePositiveInt(
 }
 
 /**
- * Forward a flag the schema knows about but the current subcommand does
- * not accept. The launcher will hand it to tsgo (or to native sidecars
- * via `--tsgo-args`); without this branch the parser would lose the
- * value token of a `--flag value` pair.
+ * Forward a flag the schema knows about but the current subcommand does not
+ * accept. The launcher will hand it to tsgo (or to native sidecars via
+ * `--tsgo-args`); without this branch the parser would lose the value token of
+ * a `--flag value` pair.
  */
 function forwardKnownButUnaccepted(
   passthrough: string[],

package/src/launcher/internal/runTtsc.ts

@@ -558,37 +558,50 @@ function runWatch(
       tsconfig: options.tsconfig,
     }),
   );
-  const directories = collectWatchDirectories(root);
-  const watchers = directories.map((dir) =>
-    fs.watch(dir, { persistent: true }, () => trigger()),
-  );
   let running = false;
   let rerun = false;
   let timer: NodeJS.Timeout | null = null;
+  // Tracks the most recent build's exit code so the watch session can exit
+  // non-zero when its latest rebuild failed, instead of always reporting 0.
+  let lastStatus = 0;
 
   const runOnce = () => {
     running = true;
-    if (!options.preserveWatchOutput) {
-      process.stdout.write("\x1bc");
+    try {
+      if (!options.preserveWatchOutput) {
+        process.stdout.write("\x1bc");
+      }
+      process.stdout.write(
+        `[ttsc] rebuilding at ${new Date().toLocaleTimeString()}\n`,
+      );
+      // The debounced rebuild fires from setTimeout, outside runTtsc's
+      // top-level try/catch. runBuild/runSingleFile/loadProjectPlugins/
+      // readProjectConfig can throw (plugin go-build failure, tsconfig edited
+      // to invalid JSON, single-file invariant). Catch here so a throwing
+      // rebuild reports a clear failure and the watcher keeps running instead
+      // of crashing the process with an uncaught exception.
+      const status =
+        invocation.files.length !== 0
+          ? runSingleFile(invocation)
+          : (() => {
+              const result = runBuild(
+                checkOnly ? { ...invocation, emit: false } : invocation,
+              );
+              if (result.stdout) process.stdout.write(result.stdout);
+              if (result.stderr) process.stderr.write(result.stderr);
+              return result.status;
+            })();
+      lastStatus = status;
+      process.stdout.write(
+        `[ttsc] ${status === 0 ? "watch build complete" : "watch build failed"}\n`,
+      );
+    } catch (error) {
+      process.stderr.write(`${formatError(error)}\n`);
+      lastStatus = lastStatus === 0 ? 2 : lastStatus;
+      process.stdout.write(`[ttsc] watch build failed\n`);
+    } finally {
+      running = false;
     }
-    process.stdout.write(
-      `[ttsc] rebuilding at ${new Date().toLocaleTimeString()}\n`,
-    );
-    const status =
-      invocation.files.length !== 0
-        ? runSingleFile(invocation)
-        : (() => {
-            const result = runBuild(
-              checkOnly ? { ...invocation, emit: false } : invocation,
-            );
-            if (result.stdout) process.stdout.write(result.stdout);
-            if (result.stderr) process.stderr.write(result.stderr);
-            return result.status;
-          })();
-    process.stdout.write(
-      `[ttsc] ${status === 0 ? "watch build complete" : "watch build failed"}\n`,
-    );
-    running = false;
     if (rerun) {
       rerun = false;
       trigger();
@@ -603,22 +616,52 @@ function runWatch(
     timer = setTimeout(runOnce, 60);
   };
 
+  const directories = collectWatchDirectories(root);
+  const watchers = directories.map((dir) => {
+    const watcher = fs.watch(dir, { persistent: true }, () => trigger());
+    // Without an error handler Node rethrows watcher errors as uncaught
+    // exceptions, which would crash the session. inotify limits (ENOSPC) and
+    // transient FS errors should be logged while the session stays alive.
+    watcher.on("error", (err) => {
+      process.stderr.write(
+        `[ttsc] watch error on ${path.relative(cwd, dir) || "."}: ${formatError(err)}\n`,
+      );
+    });
+    return watcher;
+  });
+
   const close = () => {
     if (timer) clearTimeout(timer);
     for (const watcher of watchers) watcher.close();
   };
   process.on("SIGINT", () => {
     close();
-    process.exit(0);
+    process.exit(toExitCode(lastStatus));
   });
   process.on("SIGTERM", () => {
     close();
-    process.exit(0);
+    process.exit(toExitCode(lastStatus));
   });
 
   process.stdout.write(`[ttsc] watching ${path.relative(cwd, root) || "."}\n`);
-  runOnce();
-  return 0;
+  try {
+    runOnce();
+  } catch (error) {
+    // runOnce already swallows build throws, but guard against any unforeseen
+    // throw escaping the first pass: tear down the persistent watchers so the
+    // event loop drains and the process exits cleanly with a non-zero code
+    // instead of hanging on live fs.watch handles.
+    close();
+    process.stderr.write(`${formatError(error)}\n`);
+    return toExitCode(lastStatus === 0 ? 2 : lastStatus);
+  }
+  return toExitCode(lastStatus);
+}
+
+// Coerces a build status into a valid process exit code: 0 stays 0, any
+// non-zero (or non-finite) status collapses to 1 so the session signals failure.
+function toExitCode(status: number): number {
+  return Number.isInteger(status) && status >= 0 && status <= 255 ? status : 1;
 }
 
 function collectWatchDirectories(root: string): string[] {

package/src/plugin/internal/buildSourcePlugin.ts

@@ -1004,8 +1004,51 @@ function isHashableFile(name: string): boolean {
   return !name.endsWith("~");
 }
 
+// Per-process memo for the Go compiler identity. `computeCacheKey` runs once
+// per source plugin, so an N-plugin project that points every plugin at the
+// same toolchain would otherwise pay N `go version` spawns plus N ~150MB
+// binary hashes for a value that does not change between plugins. The result
+// is a pure function of the go binary's resolved real path plus its on-disk
+// content; the memo key therefore mixes the resolved real path with a cheap
+// content signature (byte size + nanosecond mtime). That signature changes if
+// a long-lived host rewrites the binary in place between calls, so the memo
+// re-derives the identity exactly as the un-memoized code would and the
+// cache-key bytes stay byte-for-byte identical to today. `go version` reads no
+// cwd/custom env (the spawn passes neither), so cwd is not part of the key.
+const goCompilerIdentityCache = new Map<string, string>();
+
 function resolveGoCompilerIdentity(goBinary: string): string {
   const resolved = resolveExecutableIdentityPath(goBinary);
+  const memoKey = goCompilerIdentityMemoKey(goBinary, resolved);
+  if (memoKey !== null) {
+    const cached = goCompilerIdentityCache.get(memoKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+  }
+  const identity = computeGoCompilerIdentity(goBinary, resolved);
+  if (memoKey !== null) {
+    goCompilerIdentityCache.set(memoKey, identity);
+  }
+  return identity;
+}
+
+// Build a memo key that pins both the resolved binary path and its current
+// content. Returns null (skip caching, recompute) when the binary cannot be
+// stat-ed, so the rare unstattable case never serves a stale identity.
+function goCompilerIdentityMemoKey(
+  goBinary: string,
+  resolved: string,
+): string | null {
+  try {
+    const stat = fs.statSync(resolved);
+    return `${goBinary}\0${resolved}\0${stat.size}\0${stat.mtimeMs}`;
+  } catch {
+    return null;
+  }
+}
+
+function computeGoCompilerIdentity(goBinary: string, resolved: string): string {
   if (!fs.existsSync(resolved)) {
     return "missing";
   }

package/src/structures/ITtscCompilerResult.ts

@@ -87,8 +87,8 @@ export namespace ITtscCompilerResult {
      * origin. Treat as `"unknown"` when missing.
      *
      * - `"plugin"`: a native plugin sidecar crashed or exited non-zero.
-     * - `"host"`: the TypeScript-Go host could not start (missing binary,
-     *   cache lock, invalid config).
+     * - `"host"`: the TypeScript-Go host could not start (missing binary, cache
+     *   lock, invalid config).
      * - `"unknown"`: any other host-level failure.
      */
     kind?: "plugin" | "host" | "unknown";

package/src/structures/ITtscCompilerTransformation.ts

@@ -62,8 +62,8 @@ export namespace ITtscCompilerTransformation {
      * origin. Treat as `"unknown"` when missing.
      *
      * - `"plugin"`: a native plugin sidecar crashed or exited non-zero.
-     * - `"host"`: the TypeScript-Go host could not start (missing binary,
-     *   cache lock, invalid config).
+     * - `"host"`: the TypeScript-Go host could not start (missing binary, cache
+     *   lock, invalid config).
      * - `"unknown"`: any other host-level failure.
      */
     kind?: "plugin" | "host" | "unknown";