ttsc 0.21.0 → 0.23.0

package/src/plugin/internal/descriptorProcessFailure.ts

@@ -0,0 +1,100 @@
+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,
+});
+
+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.
+ */
+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}`,
+    );
+  }
+  if (result.signal) {
+    return new Error(
+      `ttsc: plugin descriptor "${request}" evaluation through ttsx was killed by signal ${result.signal}.`,
+    );
+  }
+  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),
+    );
+  }
+  return undefined;
+}
+
+/**
+ * Pass the semantic deadline and private status pipe through the `ttsx` wrapper
+ * to the runtime child that actually executes the descriptor.
+ */
+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");
+}
+
+const PLUGIN_DESCRIPTOR_REASON_LINES = 5;
+const PLUGIN_DESCRIPTOR_REASON_MAX_CHARS = 8 * 1024;

package/src/plugin/internal/loadProjectPlugins.ts

@@ -15,6 +15,13 @@ import type { TtscPluginStage } from "../../structures/TtscPluginStage";
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
 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,
+  pluginDescriptorProcessFailure,
+} from "./descriptorProcessFailure";
 
 const GO_MOD_SEARCH_MAX_DEPTH = 3;
 
@@ -65,6 +72,7 @@ export function loadProjectPlugins(options: {
   entries?: readonly ITtscProjectPluginConfig[] | false;
   env?: NodeJS.ProcessEnv;
   file?: string;
+  onWatchInputs?: (inputs: readonly string[]) => void;
   pluginConfigDir?: string;
   projectRoot?: string;
   tsconfig?: string;
@@ -86,6 +94,7 @@ export function loadProjectPlugins(options: {
           (entry) => entry.config.enabled !== false,
         );
   if (entries.length === 0) {
+    options.onWatchInputs?.([]);
     return {
       nativePlugins: [],
       project,
@@ -150,6 +159,12 @@ export function loadProjectPlugins(options: {
       stage,
     };
   });
+  options.onWatchInputs?.(
+    records.flatMap((record) => [
+      record.source,
+      ...(record.contributors?.map((contributor) => contributor.source) ?? []),
+    ]),
+  );
   const linkedContributors = records
     .filter((record) => record.stage === "transform")
     .flatMap((record) =>
@@ -758,25 +773,51 @@ 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,
+        ),
+      ],
       windowsHide: true,
     });
-    if (result.status !== 0 || !fs.existsSync(out)) {
+    const processFailure = pluginDescriptorProcessFailure(result, request);
+    if (processFailure) throw processFailure;
+    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: failed to load plugin descriptor "${request}" through ttsx`,
-          result.stderr || result.stdout || "",
-        ]
-          .filter((line) => line.trim().length !== 0)
-          .join("\n"),
+        `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);
+    } catch (error) {
+      throw new Error(
+        `ttsc: plugin descriptor "${request}" produced invalid JSON: ${errorMessage(error)}`,
       );
     }
-    return JSON.parse(fs.readFileSync(out, "utf8"));
   } finally {
     fs.rmSync(dir, { force: true, recursive: true });
   }
 }
 
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 function withPluginLoaderEnv<T>(run: () => T): T {
   const previousNode = process.env.TTSC_NODE_BINARY;
   const previousTtsx = process.env.TTSC_TTSX_BINARY;

package/src/structures/ITtscPluginCapabilities.ts

@@ -46,6 +46,40 @@ export interface ITtscPluginCapabilities {
    */
   projectContextArgs?: boolean;
 
+  /**
+   * Whether the LSP sidecar implements the standalone `lsp-project-diagnostics`
+   * command.
+   *
+   * The command evaluates project rules without an open document. It is
+   * independent of `projectInputs`, which publishes only filesystem topology.
+   *
+   * @default false
+   */
+  projectDiagnostics?: boolean;
+
+  /**
+   * Whether the sidecar implements the `project-inputs` command. The command
+   * publishes normalized exact paths and glob populations declared by enabled
+   * project rules without loading a TypeScript Program.
+   *
+   * @default false
+   */
+  projectInputs?: boolean;
+
+  /**
+   * Whether the check-stage sidecar implements the newline-delimited
+   * `check-serve` protocol used by `ttsc check --watch`.
+   *
+   * A resident check host keeps one no-emit TypeScript Program across
+   * compatible source and declared external-input changes while constructing a
+   * fresh rule engine and reporter for every request. The launcher retains the
+   * spawn-per-cycle path when this capability is absent and never uses it for
+   * transform or emit work.
+   *
+   * @default false
+   */
+  residentCheck?: boolean;
+
   /**
    * Whether the sidecar accepts `--singleThreaded` and `--checkers` on its
    * command line. The lint sidecar parses both flags via `parseSubcommandFlags`

package/src/structures/internal/ITtscProjectInputSnapshot.ts

@@ -0,0 +1,29 @@
+/** Normalized local filesystem dependencies published by project rules. */
+export interface ITtscProjectInputSnapshot {
+  /** Exact absolute paths, retained even while missing. */
+  files: readonly string[];
+  /** Absolute glob patterns using forward-slash separators. */
+  globs: readonly string[];
+  /** Exact paths whose change invalidates plugin/execution selection. */
+  reloadFiles?: readonly string[];
+  /** Directories whose immediate topology changes execution selection. */
+  reloadDirectories?: readonly string[];
+  /** Physical project root that anchored relative declarations. */
+  root: string;
+  /**
+   * The spellings the contributors published, before identity normalization.
+   *
+   * Normalizing a declaration resolves it through every symlink on its way, so
+   * the retained snapshot names the file the link currently points at rather
+   * than the link. That is what every comparison needs and the wrong thing to
+   * watch: retargeting or replacing the link is exactly what decides which
+   * bytes the declaration names next, and it happens at the spelling that
+   * normalization discarded. Consumers that install watchers keep both.
+   */
+  declared?: {
+    files: readonly string[];
+    globs: readonly string[];
+    reloadFiles?: readonly string[];
+    reloadDirectories?: readonly string[];
+  };
+}

package/src/structures/internal/TtscSingleFileEmitOptions.ts

@@ -1,3 +1,4 @@
+import type { ITtscProjectInputSnapshot } from "./ITtscProjectInputSnapshot";
 import type { TtscCommonOptions } from "./TtscCommonOptions";
 
 /** Internal options for emitting one source file through the file-argument path. */
@@ -10,4 +11,8 @@ export interface TtscSingleFileEmitOptions extends TtscCommonOptions {
   out?: string;
   /** Suppress summary banners from ttsc/native sidecars. Defaults to `true`. */
   quiet?: boolean;
+  /** Receive native-plugin source roots when a watch owns this invocation. */
+  onWatchInputs?: (inputs: readonly string[]) => void;
+  /** Receive project-rule filesystem inputs when a watch owns this invocation. */
+  onProjectInputs?: (inputs: ITtscProjectInputSnapshot) => void;
 }

package/tools/shim_audit/baseline.json

@@ -40,7 +40,6 @@
     "ESCAPE|checker|VerbosityContext",
     "ESCAPE|core|LimitedSemaphore",
     "ESCAPE|core|ModuleDetectionKind",
-    "ESCAPE|core|ModuleResolutionKind",
     "ESCAPE|core|NewLineKind",
     "ESCAPE|core|ParsedOptions",
     "ESCAPE|core|Pattern",
@@ -194,8 +193,6 @@
     "FUNC|ast|IsBindableStaticAccessExpression",
     "FUNC|ast|IsBindableStaticElementAccessExpression",
     "FUNC|ast|IsBindableStaticNameExpression",
-    "FUNC|ast|IsBindingElement",
-    "FUNC|ast|IsBindingPattern",
     "FUNC|ast|IsBitwiseOperator",
     "FUNC|ast|IsBitwiseOperatorOrHigher",
     "FUNC|ast|IsBlock",
@@ -239,10 +236,8 @@
     "FUNC|ast|IsContextualKeyword",
     "FUNC|ast|IsContinueStatement",
     "FUNC|ast|IsDebuggerStatement",
-    "FUNC|ast|IsDeclaration",
     "FUNC|ast|IsDeclarationBindingElement",
     "FUNC|ast|IsDeclarationName",
-    "FUNC|ast|IsDeclarationNameOrImportPropertyName",
     "FUNC|ast|IsDeclarationNode",
     "FUNC|ast|IsDeclarationStatement",
     "FUNC|ast|IsDecorator",
@@ -279,7 +274,6 @@
     "FUNC|ast|IsExportSpecifier",
     "FUNC|ast|IsExportsIdentifier",
     "FUNC|ast|IsExpression",
-    "FUNC|ast|IsExpressionNode",
     "FUNC|ast|IsExpressionOfOptionalChainRoot",
     "FUNC|ast|IsExpressionStatement",
     "FUNC|ast|IsExpressionWithTypeArguments",
@@ -567,15 +561,12 @@
     "FUNC|ast|IsThisTypeNode",
     "FUNC|ast|IsThrowStatement",
     "FUNC|ast|IsToken",
-    "FUNC|ast|IsTokenKind",
     "FUNC|ast|IsTrivia",
     "FUNC|ast|IsTriviaKind",
     "FUNC|ast|IsTryStatement",
     "FUNC|ast|IsTupleTypeNode",
     "FUNC|ast|IsTypeAliasDeclaration",
     "FUNC|ast|IsTypeAssertion",
-    "FUNC|ast|IsTypeDeclaration",
-    "FUNC|ast|IsTypeDeclarationName",
     "FUNC|ast|IsTypeElement",
     "FUNC|ast|IsTypeKeywordToken",
     "FUNC|ast|IsTypeLiteralNode",