@ttsc/lint 0.23.0 → 0.25.0

package/src/internal/configEvaluatorFailure.ts

@@ -1,51 +1,31 @@
-export const CONFIG_EVALUATOR_MAX_BUFFER = 16 * 1024 * 1024;
-export const CONFIG_EVALUATOR_TIMEOUT_MS = 60_000;
-export const CONFIG_EVALUATOR_TEARDOWN_GRACE_MS = 5_000;
-export const CONFIG_EVALUATOR_STATUS_FD = 3;
-export const CONFIG_EVALUATOR_PROCESS_OPTIONS = Object.freeze({
-  killSignal: "SIGKILL" as const,
-  maxBuffer: CONFIG_EVALUATOR_MAX_BUFFER,
-  timeout: CONFIG_EVALUATOR_TIMEOUT_MS + CONFIG_EVALUATOR_TEARDOWN_GRACE_MS,
-});
+import fs from "node:fs";
 
 interface ConfigEvaluatorProcessResult {
   error?: Error;
-  output?: readonly (string | null)[] | null;
   signal: NodeJS.Signals | null;
   status: number | null;
-  stderr: string | null | undefined;
 }
 
 /**
  * Classify the ways the isolated lint-config 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. A
- * bare signal is an external termination and a non-zero status is an evaluator
- * failure whose stderr tail contains the useful user-config diagnostic.
+ * The evaluator 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 config
+ * had run too long or said too much. A slow config is a slow build the user can
+ * watch and interrupt; a loud one is output they asked for. Neither is this
+ * process's memory to spend either, because the child's streams are no longer
+ * collected into it.
  */
 export function configEvaluatorProcessFailure(
   result: ConfigEvaluatorProcessResult,
   configPath: string,
 ): Error | undefined {
-  const code = (result.error as NodeJS.ErrnoException | undefined)?.code;
-  const nestedCode = result.output?.[CONFIG_EVALUATOR_STATUS_FD]?.trim() ?? "";
-  if (code === "ETIMEDOUT" || nestedCode === "ETIMEDOUT") {
-    return new Error(
-      `@ttsc/lint: ttsx evaluation of ${configPath} timed out after ` +
-        `${CONFIG_EVALUATOR_TIMEOUT_MS / 1_000} seconds. ` +
-        "Simplify the config or move heavy work out of top-level.",
-    );
-  }
-  if (code === "ENOBUFS" || nestedCode === "ENOBUFS") {
-    return new Error(
-      `@ttsc/lint: ttsx evaluation of ${configPath} exceeded the ` +
-        `${CONFIG_EVALUATOR_MAX_BUFFER / (1024 * 1024)} MiB output limit. ` +
-        "Reduce console output from the config and its dependencies.",
-    );
-  }
   if (result.error) {
     return new Error(
       `@ttsc/lint: failed to spawn ttsx for ${configPath}: ${result.error.message}`,
@@ -57,43 +37,34 @@ export function configEvaluatorProcessFailure(
     );
   }
   if (result.status !== 0) {
-    const reason = configEvaluatorFailureReason(result.stderr);
     return new Error(
-      `@ttsc/lint: lint config ${configPath} evaluation failed with exit code ${String(result.status)}` +
-        (reason === "" ? "" : "\n" + reason),
+      `@ttsc/lint: lint config ${configPath} evaluation 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 config.
- */
-export function configEvaluatorBoundaryEnvironment(
-  now: number = Date.now(),
-): NodeJS.ProcessEnv {
-  return {
-    TTSC_TTSX_EVALUATOR_DEADLINE_MS: String(now + CONFIG_EVALUATOR_TIMEOUT_MS),
-    TTSC_TTSX_EVALUATOR_MAX_BUFFER_BYTES: String(CONFIG_EVALUATOR_MAX_BUFFER),
-    TTSC_TTSX_EVALUATOR_STATUS_FD: String(CONFIG_EVALUATOR_STATUS_FD),
-  };
-}
-
-/**
- * Return the useful tail of evaluator stderr without turning an exception into
- * an unbounded duplicate of the already-forwarded child stream.
+ * Read the failure envelope the evaluator 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 configEvaluatorProcessFailure} 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 evaluation payload never
+ * carries this key, and every other shape — an absent file, a build that failed
+ * before the loader ran, a half-written result, a payload written before a
+ * later non-zero exit — leaves the process status to speak for itself.
  */
-function configEvaluatorFailureReason(
-  stderr: string | null | undefined,
-): string {
-  const bounded = (stderr ?? "").slice(-CONFIG_EVALUATOR_REASON_MAX_CHARS);
-  const lines = bounded
-    .split(/\r?\n/)
-    .map((line) => line.trimEnd())
-    .filter((line) => line.trim() !== "");
-  return lines.slice(-CONFIG_EVALUATOR_REASON_LINES).join("\n");
+export function configEvaluatorFailureReason(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 CONFIG_EVALUATOR_REASON_LINES = 5;
-const CONFIG_EVALUATOR_REASON_MAX_CHARS = 8 * 1024;