@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-IWBHRSG7.js

@@ -0,0 +1,936 @@
+import {
+  detectResolverUnavailableBlocker
+} from "./chunk-6TBEX4R4.js";
+import {
+  runInCheckoutQueue,
+  runVerificationArgv,
+  runVerificationCommand
+} from "./chunk-S2E632FQ.js";
+import {
+  buildProjectVerificationGuidance,
+  detectProjectCapabilities,
+  resolveVerificationChannelScope,
+  typescriptConfigHasProjectReferences
+} from "./chunk-AHU3FKPA.js";
+import {
+  describeVerificationCommand,
+  detectExitZeroVerifyFailure,
+  isMissingToolLaunch,
+  resolveVerificationExitCode
+} from "./chunk-EPAMVGI3.js";
+import {
+  resolveVerifyCommandTimeoutMs
+} from "./chunk-2VUEDIUM.js";
+import {
+  tailLines,
+  truncateToByteLimit
+} from "./chunk-2VLJUXJU.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/core/judge/build-gate.ts
+import { existsSync } from "fs";
+import * as path from "path";
+
+// src/core/verification/gate-build-residue.ts
+import { createHash } from "crypto";
+import { constants } from "fs";
+import { lstat, open, rm } from "fs/promises";
+import { join, resolve } from "path";
+var BINARY_SNIFF_BYTES = 8e3;
+async function listUntrackedFiles(cwd) {
+  try {
+    const result = await execGit(["ls-files", "--others", "--exclude-standard", "-z"], { cwd });
+    if (result.exitCode !== 0) return void 0;
+    return new Set(result.stdout.split("\0").filter((entry) => entry.length > 0));
+  } catch {
+    return void 0;
+  }
+}
+var metadata = (stats) => [stats.dev, stats.ino, stats.size, stats.mode, stats.mtimeMs, stats.ctimeMs].join(":");
+async function binaryFingerprint(absolutePath) {
+  const stats = await lstat(absolutePath);
+  if (!stats.isFile()) return void 0;
+  const handle = await open(absolutePath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const opened = await handle.stat();
+    if (!opened.isFile() || metadata(stats) !== metadata(opened)) return void 0;
+    const buffer = Buffer.alloc(BINARY_SNIFF_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, BINARY_SNIFF_BYTES, 0);
+    if (!buffer.subarray(0, bytesRead).includes(0)) return void 0;
+    const hash = createHash("sha256");
+    for await (const chunk of handle.createReadStream({ start: 0, autoClose: false }))
+      hash.update(chunk);
+    const after = await handle.stat();
+    const current = await lstat(absolutePath);
+    if (!current.isFile() || metadata(opened) !== metadata(after) || metadata(opened) !== metadata(current))
+      return void 0;
+    return {
+      dev: opened.dev,
+      ino: opened.ino,
+      size: opened.size,
+      mode: opened.mode,
+      mtimeMs: opened.mtimeMs,
+      ctimeMs: opened.ctimeMs,
+      hash: hash.digest("hex")
+    };
+  } finally {
+    await handle.close();
+  }
+}
+var same = (left, right) => metadata(left) === metadata(right) && left.hash === right.hash;
+var rewritten = (before, after) => before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.hash !== after.hash;
+function createBinaryBuildResidueCollector(cwd) {
+  const owned = /* @__PURE__ */ new Map();
+  let processSurvived = false;
+  const fingerprint = (relative) => binaryFingerprint(join(cwd, relative)).catch(() => void 0);
+  return {
+    preserve() {
+      processSurvived = true;
+    },
+    async capture(run) {
+      const before = await listUntrackedFiles(cwd);
+      const prior = /* @__PURE__ */ new Map();
+      for (const relative of owned.keys()) prior.set(relative, await fingerprint(relative));
+      try {
+        const result = await run();
+        if (result && typeof result === "object" && "processGroupSurvived" in result && result.processGroupSurvived === true)
+          processSurvived = true;
+        return result;
+      } finally {
+        if (before && !processSurvived) {
+          const after = await listUntrackedFiles(cwd);
+          for (const relative of after ?? []) {
+            if (before.has(relative) && !owned.has(relative)) continue;
+            const next = await fingerprint(relative);
+            if (!next) continue;
+            if (!before.has(relative)) owned.set(relative, next);
+            else {
+              const expected = owned.get(relative);
+              const previous = prior.get(relative);
+              if (expected && previous && (same(expected, previous) || rewritten(previous, next)))
+                owned.set(relative, next);
+            }
+          }
+        }
+      }
+    },
+    async cleanup() {
+      if (processSurvived) return;
+      const untracked = await listUntrackedFiles(cwd);
+      for (const [relative, expected] of owned) {
+        if (!untracked?.has(relative)) continue;
+        const current = await fingerprint(relative);
+        if (!current || !same(expected, current)) continue;
+        const absolute = join(cwd, relative);
+        try {
+          const latest = await lstat(absolute);
+          if (latest.isFile() && metadata(current) === metadata(latest))
+            await rm(absolute, { force: true });
+        } catch {
+        }
+      }
+      owned.clear();
+    }
+  };
+}
+function buildResidueCapture(cwd, collector) {
+  return async (run) => {
+    const owner = collector ?? createBinaryBuildResidueCollector(cwd);
+    try {
+      return await owner.capture(run);
+    } finally {
+      if (!collector) await owner.cleanup();
+    }
+  };
+}
+async function sharedBuildResidueCollector(cache, cwd, inCheckoutQueue) {
+  if (!cache?.deferCleanup) return void 0;
+  const key = JSON.stringify(["build-products", resolve(cwd)]);
+  return cache.run(key, async () => {
+    const collector = createBinaryBuildResidueCollector(cwd);
+    cache.deferCleanup(key, () => inCheckoutQueue(cwd, () => collector.cleanup()));
+    return collector;
+  });
+}
+function deferredBuildResidueCapture(cache, cwd, inCheckoutQueue) {
+  return cache?.deferCleanup ? async (run) => {
+    const collector = await sharedBuildResidueCollector(cache, cwd, inCheckoutQueue);
+    return collector ? collector.capture(run) : run();
+  } : void 0;
+}
+
+// src/core/judge/gate-output-tail.ts
+var GATE_OUTPUT_TAIL_LINES = 200;
+
+// src/core/judge/tool-unavailable-coverage.ts
+function toolUnavailableCoverage(params) {
+  const { command, subject } = params;
+  if (isMissingToolLaunch(params.exitCode, params.errorCode)) {
+    return {
+      status: "skipped_tool_unavailable",
+      command,
+      reason: `${subject} command was unavailable in the execution environment.`
+    };
+  }
+  const blocker = detectResolverUnavailableBlocker(command, params.output, params.exitCode);
+  return blocker ? { status: "skipped_tool_unavailable", command, reason: blocker } : void 0;
+}
+
+// src/core/judge/verification-run-cache.ts
+function isExecutionFailureCoverage(coverage) {
+  return coverage?.status === "unverified" || coverage?.status === "partially_verified" || coverage?.status === "skipped_tool_unavailable";
+}
+function abortError(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error ? reason : new Error("Verification run aborted");
+}
+function createVerificationRunCache(parentSignal) {
+  const entries = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const cleanups = /* @__PURE__ */ new Map();
+  let disposal;
+  let closed = false;
+  const track = (promise) => {
+    pending.add(promise);
+    promise.then(
+      () => pending.delete(promise),
+      () => pending.delete(promise)
+    );
+    return promise;
+  };
+  const start = (key, runner, retain) => {
+    const controller = new AbortController();
+    const entry = { promise: Promise.resolve(), controller, consumers: 0 };
+    const evict = () => {
+      if (entries.get(key) === entry) entries.delete(key);
+    };
+    controller.signal.addEventListener("abort", evict, { once: true });
+    const onParentAbort = () => controller.abort(parentSignal?.reason);
+    if (parentSignal?.aborted) onParentAbort();
+    else parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+    entry.promise = Promise.resolve().then(() => runner(controller.signal)).then((value) => {
+      if (retain && !retain(value)) evict();
+      return value;
+    }).catch((error) => {
+      evict();
+      throw error;
+    }).finally(() => parentSignal?.removeEventListener("abort", onParentAbort));
+    entry.promise.catch(() => void 0);
+    track(entry.promise);
+    entries.set(key, entry);
+    return entry;
+  };
+  return {
+    track,
+    deferCleanup(key, cleanup) {
+      if (!cleanups.has(key)) cleanups.set(key, cleanup);
+    },
+    dispose() {
+      if (!disposal) {
+        closed = true;
+        disposal = (async () => {
+          while (pending.size > 0) await Promise.allSettled([...pending]);
+          await Promise.allSettled([...cleanups.values()].map((cleanup) => cleanup()));
+          entries.clear();
+          cleanups.clear();
+        })();
+      }
+      return disposal;
+    },
+    run(key, runner, consumerSignal, retain) {
+      const existing = entries.get(key);
+      if (closed && !existing)
+        return Promise.reject(new Error("Verification cache owner has finished"));
+      if (consumerSignal?.aborted) return Promise.reject(abortError(consumerSignal));
+      const entry = existing ?? start(key, runner, retain);
+      entry.consumers += 1;
+      return new Promise((resolve2, reject) => {
+        let detached = false;
+        const onConsumerAbort = () => {
+          detached = true;
+          entry.consumers -= 1;
+          if (entry.consumers === 0) entry.controller.abort(consumerSignal?.reason);
+          reject(abortError(consumerSignal));
+        };
+        consumerSignal?.addEventListener("abort", onConsumerAbort, { once: true });
+        entry.promise.then(
+          (value) => {
+            consumerSignal?.removeEventListener("abort", onConsumerAbort);
+            if (!detached) resolve2(value);
+          },
+          (error) => {
+            consumerSignal?.removeEventListener("abort", onConsumerAbort);
+            if (!detached) reject(error);
+          }
+        );
+      });
+    }
+  };
+}
+function runShared(scope, parts, consumerSignal, run, retain) {
+  if (!scope) return run(consumerSignal);
+  return scope.cache.run(JSON.stringify([scope.identity, ...parts]), run, consumerSignal, retain);
+}
+
+// src/core/judge/build-gate.ts
+function resolveTscExecutable(repoPath) {
+  const candidate = path.join(
+    repoPath,
+    "node_modules",
+    ".bin",
+    process.platform === "win32" ? "tsc.cmd" : "tsc"
+  );
+  return existsSync(candidate) ? candidate : "tsc";
+}
+function isTimeoutLike(error) {
+  return error.code === "ETIMEDOUT" || error.timedOut === true || error.isCanceled === true || error.killed === true || error.signal === "SIGTERM";
+}
+function verificationCoverageForCommand(params) {
+  if (params.error && isTimeoutLike(params.error)) {
+    return {
+      status: "unverified",
+      command: params.command,
+      reason: "Verification command timed out or was interrupted."
+    };
+  }
+  const unavailable = toolUnavailableCoverage({
+    ...params,
+    errorCode: params.error?.code,
+    subject: "Verification"
+  });
+  if (unavailable) return unavailable;
+  if (params.exitCode === 126) {
+    return {
+      status: "unverified",
+      command: params.command,
+      reason: "Verification command was rejected before execution."
+    };
+  }
+  return { status: "verified", command: params.command };
+}
+function exitZeroFailureMessage(command, output) {
+  return detectExitZeroVerifyFailure(command, output)?.message;
+}
+function localTscExecutable(repoPath) {
+  return path.join(
+    repoPath,
+    "node_modules",
+    ".bin",
+    process.platform === "win32" ? "tsc.cmd" : "tsc"
+  );
+}
+async function runProjectBuildCommand(repoPath, command, options) {
+  const start = Date.now();
+  const timeoutMs = resolveVerifyCommandTimeoutMs(options?.timeoutMs);
+  const maxTailLines = options?.tailLines ?? GATE_OUTPUT_TAIL_LINES;
+  const language = describeVerificationCommand(command).language;
+  try {
+    const result = await runVerificationCommand(command, {
+      cwd: repoPath,
+      timeoutMs,
+      abortSignal: options?.abortSignal,
+      buildResidue: options?.buildResidue ?? (options?.keepBuildResidue ? void 0 : buildResidueCapture(repoPath))
+    });
+    const stdout = String(result.stdout ?? "");
+    const stderr = String(result.stderr ?? "");
+    const combined = String(result.all ?? `${stdout}
+${stderr}`);
+    const durationMs = Date.now() - start;
+    const stdoutTail = tailLines(stdout, maxTailLines);
+    const stderrTail = tailLines(stderr, maxTailLines);
+    const output = combined.trim();
+    const { exitCode: resolvedExitCode } = resolveVerificationExitCode(command, result);
+    const exitZeroFailure = resolvedExitCode === 0 ? exitZeroFailureMessage(command, output) : void 0;
+    const effectiveExitCode = exitZeroFailure ? 1 : resolvedExitCode;
+    const effectiveOutput = exitZeroFailure ? `${output}
+${exitZeroFailure}`.trim() : output;
+    return {
+      ok: effectiveExitCode === 0,
+      exitCode: effectiveExitCode,
+      durationMs,
+      command,
+      language,
+      output: effectiveOutput,
+      stdoutTail,
+      stderrTail,
+      outputTail: truncateToByteLimit(tailLines(effectiveOutput, maxTailLines), 1e5),
+      verificationCoverage: verificationCoverageForCommand({
+        command,
+        exitCode: effectiveExitCode,
+        output: effectiveOutput,
+        // execa runs with reject:false, so a timeout or cancel resolves here
+        // instead of reaching the catch below.
+        error: { timedOut: result.timedOut, isCanceled: result.isCanceled }
+      })
+    };
+  } catch (error) {
+    const durationMs = Date.now() - start;
+    const err = error;
+    const stdout = "stdout" in err ? String(err.stdout ?? "") : "";
+    const stderr = "stderr" in err ? String(err.stderr ?? "") : "";
+    const all = "all" in err ? String(err.all ?? "") : "";
+    const output = (all || `${stdout}
+${stderr}`).trim();
+    const exitCode = isTimeoutLike(err) ? 124 : typeof err.exitCode === "number" ? Number(err.exitCode) : typeof err.code === "number" ? Number(err.code) : typeof err.status === "number" ? Number(err.status) : 1;
+    return {
+      ok: false,
+      exitCode,
+      durationMs,
+      command,
+      language,
+      output,
+      stdoutTail: tailLines(stdout, maxTailLines),
+      stderrTail: tailLines(stderr, maxTailLines),
+      outputTail: truncateToByteLimit(tailLines(output, maxTailLines), 1e5),
+      verificationCoverage: verificationCoverageForCommand({
+        command,
+        exitCode,
+        output,
+        error: err
+      })
+    };
+  }
+}
+async function runTypecheckWithArtifacts(repoPath, options) {
+  const start = Date.now();
+  const timeoutMs = resolveVerifyCommandTimeoutMs(options?.timeoutMs);
+  const maxTailLines = options?.tailLines ?? GATE_OUTPUT_TAIL_LINES;
+  const capabilities = detectProjectCapabilities(repoPath);
+  const projectBuildGateCommand = options?.command ?? capabilities.verification.typecheck[0] ?? capabilities.verification.build[0];
+  if (projectBuildGateCommand) {
+    return runProjectBuildCommand(repoPath, projectBuildGateCommand, options);
+  }
+  const tsc = resolveTscExecutable(repoPath);
+  const typecheckConfigPath = path.join(repoPath, "tsconfig.typecheck.json");
+  const defaultConfigPath = path.join(repoPath, "tsconfig.json");
+  const selectedConfigPath = existsSync(typecheckConfigPath) ? "tsconfig.typecheck.json" : existsSync(defaultConfigPath) ? "tsconfig.json" : null;
+  const args = ["--noEmit", ...selectedConfigPath ? ["-p", selectedConfigPath] : []];
+  if (!selectedConfigPath) {
+    const durationMs = Date.now() - start;
+    const command = `${tsc} ${args.join(" ")}`;
+    const outputTail = "Skipped build verification: no project typecheck/build command detected, and no tsconfig.typecheck.json or tsconfig.json found.";
+    return {
+      ok: false,
+      exitCode: 127,
+      durationMs,
+      command,
+      // tsc fallback path: the language is unconditionally node (TS compiler),
+      // captured at the source so downstream never re-parses the local-bin path
+      // (robust to repo-path spaces/quotes).
+      language: "node",
+      output: outputTail,
+      stdoutTail: outputTail,
+      stderrTail: "",
+      outputTail,
+      verificationCoverage: {
+        status: "skipped_no_command",
+        command,
+        reason: "No project typecheck/build command, tsconfig.typecheck.json, or tsconfig.json was detected."
+      }
+    };
+  }
+  if (typescriptConfigHasProjectReferences(repoPath, selectedConfigPath)) {
+    const durationMs = Date.now() - start;
+    const command = `${tsc} --noEmit -p ${selectedConfigPath}`;
+    const outputTail = `Skipped build verification: ${selectedConfigPath} declares TypeScript project references, and no covering project typecheck/build command was detected. Simple tsc --noEmit -p is not a covering typecheck for solution-style configs.`;
+    return {
+      ok: false,
+      exitCode: 127,
+      durationMs,
+      command,
+      language: "node",
+      output: outputTail,
+      stdoutTail: outputTail,
+      stderrTail: "",
+      outputTail,
+      verificationCoverage: {
+        status: "skipped_no_command",
+        command,
+        reason: `${selectedConfigPath} declares project references; no covering typecheck/build command was available for the local-tsc fallback.`
+      }
+    };
+  }
+  const projectLocalTsc = localTscExecutable(repoPath);
+  if (tsc === "tsc" && !existsSync(projectLocalTsc)) {
+    const durationMs = Date.now() - start;
+    const command = `${tsc} ${args.join(" ")}`;
+    const outputTail = "Skipped build verification: TypeScript config was detected, but no project-local TypeScript compiler was available.";
+    return {
+      ok: false,
+      exitCode: 127,
+      durationMs,
+      command,
+      language: "node",
+      output: outputTail,
+      stdoutTail: "",
+      stderrTail: outputTail,
+      outputTail,
+      verificationCoverage: {
+        status: "skipped_tool_unavailable",
+        command,
+        reason: "No project-local TypeScript compiler was available."
+      }
+    };
+  }
+  try {
+    const result = await runVerificationArgv(tsc, args, {
+      cwd: repoPath,
+      timeoutMs,
+      abortSignal: options?.abortSignal,
+      projectLocalBin: "tsc",
+      buildResidue: options?.buildResidue ?? (options?.keepBuildResidue ? void 0 : buildResidueCapture(repoPath))
+    });
+    const durationMs = Date.now() - start;
+    const stdout = String(result.stdout ?? "");
+    const stderr = String(result.stderr ?? "");
+    const combined = String(result.all ?? `${stdout}
+${stderr}`);
+    const output = combined.trim();
+    const { exitCode: resolvedExitCode } = resolveVerificationExitCode(
+      `${tsc} ${args.join(" ")}`,
+      result
+    );
+    const exitZeroFailure = resolvedExitCode === 0 ? exitZeroFailureMessage(`${tsc} ${args.join(" ")}`, output) : void 0;
+    const effectiveExitCode = exitZeroFailure ? 1 : resolvedExitCode;
+    const effectiveOutput = exitZeroFailure ? `${output}
+${exitZeroFailure}`.trim() : output;
+    const stdoutTail = tailLines(stdout, maxTailLines);
+    const stderrTail = tailLines(stderr, maxTailLines);
+    const outputTail = truncateToByteLimit(tailLines(effectiveOutput, maxTailLines), 1e5);
+    return {
+      ok: effectiveExitCode === 0,
+      exitCode: effectiveExitCode,
+      durationMs,
+      command: `${tsc} ${args.join(" ")}`,
+      language: "node",
+      output: effectiveOutput,
+      stdoutTail,
+      stderrTail,
+      outputTail,
+      verificationCoverage: verificationCoverageForCommand({
+        command: `${tsc} ${args.join(" ")}`,
+        exitCode: effectiveExitCode,
+        output: effectiveOutput,
+        error: { timedOut: result.timedOut, isCanceled: result.isCanceled }
+      })
+    };
+  } catch (error) {
+    const durationMs = Date.now() - start;
+    const err = error;
+    const isTimeout = typeof error === "object" && error !== null && ("code" in error && err.code === "ETIMEDOUT" || "killed" in error && err.killed === true || "signal" in error && err.signal === "SIGTERM");
+    if (error && typeof error === "object") {
+      const stdout = "stdout" in error ? String(err.stdout ?? "") : "";
+      const stderr = "stderr" in error ? String(err.stderr ?? "") : "";
+      const output = `${stdout}
+${stderr}`.trim();
+      const exitCode = isTimeout ? 124 : "code" in error && typeof err.code === "number" ? Number(err.code) : "status" in error && typeof err.status === "number" ? Number(err.status) : 1;
+      const stdoutTail = tailLines(stdout, maxTailLines);
+      const stderrTail = tailLines(stderr, maxTailLines);
+      const outputTail = truncateToByteLimit(tailLines(output, maxTailLines), 1e5);
+      return {
+        ok: false,
+        exitCode,
+        durationMs,
+        command: `${tsc} ${args.join(" ")}`,
+        language: "node",
+        output,
+        stdoutTail,
+        stderrTail,
+        outputTail,
+        verificationCoverage: verificationCoverageForCommand({
+          command: `${tsc} ${args.join(" ")}`,
+          exitCode,
+          output,
+          error: err
+        })
+      };
+    }
+    return {
+      ok: false,
+      exitCode: isTimeout ? 124 : 1,
+      durationMs,
+      command: `${tsc} ${args.join(" ")}`,
+      language: "node",
+      output: "",
+      stdoutTail: "",
+      stderrTail: "",
+      outputTail: "",
+      verificationCoverage: verificationCoverageForCommand({
+        command: `${tsc} ${args.join(" ")}`,
+        exitCode: isTimeout ? 124 : 1,
+        output: "",
+        error: err
+      })
+    };
+  }
+}
+function normalizeBuildErrorKey(error) {
+  const file = path.normalize(error.file).replace(/^\.\//, "");
+  const message = error.message.replace(/\s+/g, " ").trim();
+  return `${file}::${message}`;
+}
+function scopedBuildCommands(channel) {
+  if (Array.isArray(channel.commands) && channel.commands.length > 0) return channel.commands;
+  if (typeof channel.command === "string" && channel.command.trim()) return [channel.command];
+  return [];
+}
+function uniqueCommands(commands) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const command of commands) {
+    if (seen.has(command)) continue;
+    seen.add(command);
+    unique.push(command);
+  }
+  return unique;
+}
+function buildErrorsFromArtifact(artifact) {
+  return parseTscOutput(artifact.output ?? artifact.outputTail).map(toBuildError);
+}
+function aggregateBaselineSnapshots(snapshots, typecheckExecutable) {
+  const errors = [];
+  const errorKeys = /* @__PURE__ */ new Set();
+  for (const snapshot of snapshots) {
+    for (const error of snapshot.errors) {
+      const key = normalizeBuildErrorKey(error);
+      if (errorKeys.has(key)) continue;
+      errorKeys.add(key);
+      errors.push(error);
+    }
+  }
+  return {
+    ok: snapshots.length > 0 && snapshots.every((snapshot) => snapshot.ok),
+    errorKeys,
+    errors,
+    typecheckExecutable,
+    ...snapshots.some((snapshot) => snapshot.executionFailed) ? { executionFailed: true } : {}
+  };
+}
+async function collectBaselineTypecheck(repoPath, changedFiles = [], runCache) {
+  const typecheckExecutable = resolveTscExecutable(repoPath);
+  let scopedCommands = [];
+  let skipReason;
+  try {
+    const scope = resolveVerificationChannelScope(repoPath, changedFiles);
+    if (scope.scoped) {
+      if (scope.build.availability === "unavailable") {
+        skipReason = "unavailable";
+      } else if (scope.build.availability === "out_of_scope") {
+        skipReason = "out_of_scope";
+      } else {
+        scopedCommands = scopedBuildCommands(scope.build);
+      }
+    } else if (changedFiles.length > 0) {
+      const guidance = buildProjectVerificationGuidance(repoPath, changedFiles);
+      scopedCommands = uniqueCommands([
+        ...guidance.commands.filter((command) => command.kind === "typecheck").map((command) => command.command),
+        ...guidance.commands.filter((command) => command.kind === "build").map((command) => command.command)
+      ]);
+    }
+  } catch {
+    scopedCommands = [];
+  }
+  if (skipReason === "unavailable") {
+    const unavailableError = {
+      file: changedFiles[0] ?? ".",
+      message: "Verification unavailable: no covering build/typecheck command for changed language",
+      severity: "fatal"
+    };
+    return {
+      ok: false,
+      errorKeys: /* @__PURE__ */ new Set([normalizeBuildErrorKey(unavailableError)]),
+      errors: [unavailableError],
+      typecheckExecutable
+    };
+  }
+  if (skipReason === "out_of_scope") {
+    return {
+      ok: true,
+      errorKeys: /* @__PURE__ */ new Set(),
+      errors: [],
+      typecheckExecutable
+    };
+  }
+  const commands = uniqueCommands(scopedCommands);
+  return runShared(
+    runCache && { cache: runCache, identity: "baseline" },
+    [repoPath, typecheckExecutable, commands],
+    void 0,
+    (abortSignal) => runBaselineCommands(repoPath, commands, typecheckExecutable, abortSignal),
+    (snapshot) => !snapshot.executionFailed
+  );
+}
+function baselineCommandSnapshot(artifact) {
+  return {
+    ok: artifact.ok,
+    errors: buildErrorsFromArtifact(artifact),
+    executionFailed: isExecutionFailureCoverage(artifact.verificationCoverage)
+  };
+}
+async function runBaselineCommands(repoPath, commands, typecheckExecutable, abortSignal) {
+  if (commands.length === 0) {
+    const artifact = await runTypecheckWithArtifacts(repoPath, {
+      executable: typecheckExecutable,
+      abortSignal
+    });
+    return aggregateBaselineSnapshots([baselineCommandSnapshot(artifact)], typecheckExecutable);
+  }
+  let remaining = resolveVerifyCommandTimeoutMs();
+  const snapshots = [];
+  for (const command of commands) {
+    if (remaining <= 0) {
+      snapshots.push({ ok: false, errors: [], executionFailed: true });
+      continue;
+    }
+    const artifact = await runTypecheckWithArtifacts(repoPath, {
+      executable: typecheckExecutable,
+      command,
+      timeoutMs: remaining,
+      abortSignal
+    });
+    remaining = Math.max(0, remaining - (artifact.durationMs ?? 0));
+    snapshots.push(baselineCommandSnapshot(artifact));
+  }
+  return aggregateBaselineSnapshots(snapshots, typecheckExecutable);
+}
+function parseTscOutput(output) {
+  if (!output || output.trim().length === 0) {
+    return [];
+  }
+  const errors = [];
+  const lines = output.split("\n");
+  const format1 = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/;
+  const format2 = /^(.+?):(\d+):(\d+)\s+-\s+error\s+(TS\d+):\s+(.+)$/;
+  const format3 = /^error\s+(TS\d+):\s+(.+)$/;
+  let lastError = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      lastError = null;
+      continue;
+    }
+    let match = format1.exec(trimmed);
+    if (match) {
+      const file = match[1];
+      const lineNumber = match[2];
+      const columnNumber = match[3];
+      const code = match[4];
+      const message = match[5];
+      if (file && lineNumber && columnNumber && code && message) {
+        const parsed = {
+          file,
+          line: Number.parseInt(lineNumber, 10),
+          column: Number.parseInt(columnNumber, 10),
+          code,
+          message
+        };
+        lastError = parsed;
+        errors.push(parsed);
+      }
+      continue;
+    }
+    match = format2.exec(trimmed);
+    if (match) {
+      const file = match[1];
+      const lineNumber = match[2];
+      const columnNumber = match[3];
+      const code = match[4];
+      const message = match[5];
+      if (file && lineNumber && columnNumber && code && message) {
+        const parsed = {
+          file,
+          line: Number.parseInt(lineNumber, 10),
+          column: Number.parseInt(columnNumber, 10),
+          code,
+          message
+        };
+        lastError = parsed;
+        errors.push(parsed);
+      }
+      continue;
+    }
+    match = format3.exec(trimmed);
+    if (match) {
+      const code = match[1];
+      const message = match[2];
+      if (code && message) {
+        const parsed = {
+          file: "<unknown>",
+          code,
+          message
+        };
+        lastError = parsed;
+        errors.push(parsed);
+      }
+      continue;
+    }
+    if (lastError && !trimmed.startsWith("error TS")) {
+      lastError.message += ` ${trimmed}`;
+    }
+  }
+  return errors;
+}
+function classifyErrorSeverity(errorCode, errorMessage) {
+  const code = errorCode.toUpperCase();
+  const message = errorMessage.toLowerCase();
+  if (/^TS1\d{3}$/.test(code)) {
+    return "fatal";
+  }
+  if (code === "TS2307" || code === "TS2304") {
+    return "fatal";
+  }
+  if (message.includes("unexpected token") || message.includes("parse error") || message.includes("syntax error") || message.includes("cannot find module")) {
+    return "fatal";
+  }
+  return "error";
+}
+function toBuildError(tscError) {
+  return {
+    file: tscError.file,
+    line: tscError.line,
+    message: `${tscError.code}: ${tscError.message}`,
+    severity: classifyErrorSeverity(tscError.code, tscError.message)
+  };
+}
+function commandEmitsTscDiagnostics(command) {
+  if (!command || command.trim().length === 0) {
+    return false;
+  }
+  const trimmed = command.trim();
+  if (/(?:^|[\\/])tsc(?:\.cmd)?(?:\s|$)/.test(trimmed) || trimmed.includes("--noEmit")) {
+    return true;
+  }
+  return describeVerificationCommand(trimmed).language === "node";
+}
+function buildNonNodeGateResult(typecheck, baselineHealthy, baselineErrorKeys) {
+  const coverageStatus = typecheck.verificationCoverage?.status;
+  const verificationCouldNotRun = coverageStatus === "skipped_no_command" || coverageStatus === "skipped_tool_unavailable";
+  let signal;
+  if (typecheck.ok) {
+    signal = "pass";
+  } else if (verificationCouldNotRun) {
+    signal = "unknown";
+  } else {
+    signal = baselineHealthy ? "fail" : "unknown";
+  }
+  return {
+    signal,
+    errors: [],
+    baselineComparisonAvailable: baselineErrorKeys !== void 0,
+    baselineHealthy,
+    fatalErrorCount: 0,
+    typeErrorCount: 0,
+    warningCount: 0,
+    // Counts are placeholders only; output was not parsed for this language.
+    compilerCountsAvailable: false,
+    ...typecheck.exitCode !== void 0 ? {
+      exitCode: typecheck.exitCode,
+      outputTail: typecheck.outputTail,
+      stdoutTail: typecheck.stdoutTail,
+      stderrTail: typecheck.stderrTail,
+      durationMs: typecheck.durationMs,
+      command: typecheck.command,
+      verificationCoverage: typecheck.verificationCoverage
+    } : {}
+  };
+}
+async function runBuildGate(variantPath, changedFiles, baselineHealthy, options) {
+  const timeoutMs = resolveVerifyCommandTimeoutMs(options?.timeoutMs);
+  const buildResidue = deferredBuildResidueCapture(
+    options?.runScope?.cache,
+    variantPath,
+    runInCheckoutQueue
+  );
+  const typecheck = await runShared(
+    options?.runScope,
+    ["typecheck", options?.command ?? "", options?.typecheckExecutable ?? "", timeoutMs],
+    options?.abortSignal,
+    (abortSignal) => runTypecheckWithArtifacts(variantPath, {
+      timeoutMs,
+      abortSignal,
+      executable: options?.typecheckExecutable,
+      command: options?.command,
+      // Without a lifecycle owner, keep products for dependent tests.
+      keepBuildResidue: true,
+      buildResidue
+    }),
+    (artifact) => !isExecutionFailureCoverage(artifact.verificationCoverage)
+  );
+  const tscOutput = typecheck.output ?? typecheck.outputTail;
+  if (!commandEmitsTscDiagnostics(typecheck.command)) {
+    return buildNonNodeGateResult(typecheck, baselineHealthy, options?.baselineErrorKeys);
+  }
+  const tscErrors = parseTscOutput(tscOutput);
+  const buildErrors = tscErrors.map(toBuildError);
+  const baselineErrorKeys = options?.baselineErrorKeys;
+  const baselineComparisonAvailable = baselineErrorKeys !== void 0;
+  const newErrors = baselineComparisonAvailable ? buildErrors.filter((err) => !baselineErrorKeys.has(normalizeBuildErrorKey(err))) : void 0;
+  const fatalErrors = buildErrors.filter((e) => e.severity === "fatal");
+  const typeErrors = buildErrors.filter((e) => e.severity === "error");
+  const warnings = buildErrors.filter((e) => e.severity === "warning");
+  let filteredErrors = buildErrors;
+  if (!baselineHealthy && changedFiles.length > 0) {
+    const changedFileSet = new Set(changedFiles.map((f) => path.normalize(f).replace(/^\.\//, "")));
+    filteredErrors = buildErrors.filter((err) => {
+      const normalizedFile = path.normalize(err.file).replace(/^\.\//, "");
+      return changedFileSet.has(normalizedFile);
+    });
+  }
+  let signal = "pass";
+  if (!baselineHealthy) {
+    if (newErrors) {
+      signal = newErrors.length > 0 ? "fail" : "unknown";
+      filteredErrors = newErrors;
+    } else {
+      signal = filteredErrors.length > 0 ? "fail" : "unknown";
+    }
+  } else {
+    signal = buildErrors.length > 0 ? "fail" : "pass";
+  }
+  if (signal === "pass" && (typecheck.verificationCoverage?.status === "skipped_no_command" || typecheck.verificationCoverage?.status === "skipped_tool_unavailable" || typecheck.verificationCoverage?.status === "unverified" || typecheck.exitCode === 126) && buildErrors.length === 0) {
+    signal = "unknown";
+  } else if (signal === "pass" && !typecheck.ok && buildErrors.length === 0) {
+    signal = baselineHealthy ? "fail" : "unknown";
+  }
+  return {
+    signal,
+    errors: filteredErrors,
+    ...newErrors ? {
+      newErrors,
+      newErrorCount: newErrors.length
+    } : {},
+    baselineComparisonAvailable,
+    baselineHealthy,
+    fatalErrorCount: fatalErrors.length,
+    typeErrorCount: typeErrors.length,
+    warningCount: warnings.length,
+    // Backwards-compatible extension: include execution artifacts for verification loops.
+    ...typecheck.exitCode !== void 0 ? {
+      exitCode: typecheck.exitCode,
+      outputTail: typecheck.outputTail,
+      stdoutTail: typecheck.stdoutTail,
+      stderrTail: typecheck.stderrTail,
+      durationMs: typecheck.durationMs,
+      command: typecheck.command,
+      verificationCoverage: typecheck.verificationCoverage
+    } : {}
+  };
+}
+
+export {
+  sharedBuildResidueCollector,
+  GATE_OUTPUT_TAIL_LINES,
+  toolUnavailableCoverage,
+  isExecutionFailureCoverage,
+  createVerificationRunCache,
+  runShared,
+  resolveTscExecutable,
+  runTypecheckWithArtifacts,
+  collectBaselineTypecheck,
+  parseTscOutput,
+  classifyErrorSeverity,
+  runBuildGate
+};
+//# sourceMappingURL=chunk-IWBHRSG7.js.map