@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-TUQMMFEQ.js

@@ -0,0 +1,2244 @@
+import {
+  applicableRunnerLanguages,
+  describeVerificationCommand,
+  detectZeroCollectedTests,
+  isPythonStdlibUnittestCommand,
+  runnerRowApplies
+} from "./chunk-EPAMVGI3.js";
+import {
+  isProjectSourcePath
+} from "./chunk-RPIMAMV7.js";
+import {
+  BUILD_PLAIN_LOGS,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/shared/output-processing.ts
+var ANSI_ESCAPE_SEQUENCE = /\x1B\[[0-9;?]*[ -/]*[@-~]/g;
+var OSC_ESCAPE_SEQUENCE = /\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g;
+var DCS_ESCAPE_SEQUENCE = /\x1BP(?:[^\x1B]|\x1B(?!\\))*\x1B\\/g;
+function isIgnorableProviderBannerLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  if (trimmed === "YOLO mode is enabled. All tool calls will be automatically approved." || trimmed === "Loaded cached credentials." || trimmed === "Loaded cached credentials") {
+    return true;
+  }
+  return false;
+}
+function selectBestErrorLine(output) {
+  const lines2 = output.split("\n").map((line) => line.trim()).filter((line) => !isIgnorableProviderBannerLine(line));
+  if (lines2.length === 0) return void 0;
+  const priorityMatchers = [
+    /\bModelNotFoundError\b/,
+    /\[API Error:/,
+    /\bTraceback\b/,
+    /\bException\b/,
+    /\bError\b/,
+    /\bfailed\b/i,
+    /\bnot found\b/i,
+    /\bunauthorized\b/i,
+    /\bforbidden\b/i,
+    /\brate limit\b/i,
+    /\bECONNRESET\b/,
+    /\bETIMEDOUT\b/
+  ];
+  for (const line of lines2) {
+    if (priorityMatchers.some((re) => re.test(line))) {
+      return line;
+    }
+  }
+  return lines2[0];
+}
+function selectBestErrorSummary(primaryOutput, fallbackOutput) {
+  const primaryLine = selectBestErrorLine(primaryOutput);
+  if (primaryLine) {
+    return primaryLine;
+  }
+  if (fallbackOutput) {
+    const fallbackLine = selectBestErrorLine(fallbackOutput);
+    if (fallbackLine) {
+      return fallbackLine;
+    }
+  }
+  return primaryOutput.split("\n")[0]?.trim() || fallbackOutput?.split("\n")[0]?.trim();
+}
+function stripCarriageReturnOverwrites(text) {
+  if (!text.includes("\r")) {
+    return text;
+  }
+  const pieces = text.split("\n");
+  for (let i = 0; i < pieces.length; i++) {
+    let piece = pieces[i] ?? "";
+    let crlfSuffix = "";
+    if (piece.endsWith("\r") && i < pieces.length - 1) {
+      crlfSuffix = "\r";
+      piece = piece.slice(0, -1);
+    }
+    const lastBareCr = piece.lastIndexOf("\r");
+    if (lastBareCr !== -1) {
+      piece = piece.slice(lastBareCr + 1);
+    }
+    pieces[i] = piece + crlfSuffix;
+  }
+  return pieces.join("\n");
+}
+function normalizeOutput(text) {
+  const plainLogs = readEnv(BUILD_PLAIN_LOGS).value;
+  let result = stripCarriageReturnOverwrites(text);
+  if (plainLogs) {
+    result = result.replace(ANSI_ESCAPE_SEQUENCE, "").replace(OSC_ESCAPE_SEQUENCE, "").replace(DCS_ESCAPE_SEQUENCE, "");
+  }
+  result = result.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n");
+  return result;
+}
+function processOutput(stdout, stderr, onData, onErrorData, formatLine, passThroughUnformatted = false) {
+  if (onData && stdout) {
+    const normalized = normalizeOutput(stdout);
+    const lines2 = normalized.trim().split("\n");
+    for (const line of lines2) {
+      if (!line.trim()) continue;
+      if (formatLine) {
+        const formatted = formatLine(line);
+        if (formatted) {
+          onData(`${formatted}
+`);
+        } else if (passThroughUnformatted) {
+          onData(`${line}
+`);
+        }
+      } else {
+        onData(`${line}
+`);
+      }
+    }
+  }
+  if (onErrorData && stderr) {
+    const normalized = normalizeOutput(stderr);
+    onErrorData(normalized);
+  }
+}
+function chunkToText(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (Buffer.isBuffer(chunk)) {
+    return chunk.toString("utf-8");
+  }
+  return "";
+}
+function createLineBufferedStreamProcessor(onLine) {
+  let buffer = "";
+  let emittedContentLine = false;
+  const emitLine = (rawLine, isFinal) => {
+    const normalized = normalizeOutput(rawLine);
+    if (!normalized.trim()) {
+      return;
+    }
+    const adjusted = emittedContentLine ? normalized : normalized.trimStart();
+    const finalAdjusted = isFinal ? adjusted.trimEnd() : adjusted;
+    if (!finalAdjusted.trim()) {
+      return;
+    }
+    emittedContentLine = true;
+    onLine(finalAdjusted, isFinal);
+  };
+  return {
+    push(chunk) {
+      const text = chunkToText(chunk);
+      if (!text) {
+        return;
+      }
+      buffer += text;
+      buffer = buffer.replace(/\r\n/g, "\n");
+      const lines2 = buffer.split("\n");
+      buffer = lines2.pop() ?? "";
+      for (const line of lines2) {
+        emitLine(line, false);
+      }
+    },
+    flush() {
+      if (!buffer) {
+        return;
+      }
+      emitLine(buffer, true);
+      buffer = "";
+    }
+  };
+}
+function stripAnsiSequences(str) {
+  return str.replace(ANSI_ESCAPE_SEQUENCE, "").replace(OSC_ESCAPE_SEQUENCE, "").replace(DCS_ESCAPE_SEQUENCE, "");
+}
+
+// src/core/judge/test-gate-runners.ts
+var RESOLVER_SUITE_RUNNERS = [
+  "ruby",
+  "php",
+  "dotnet",
+  "swift",
+  "dart",
+  "native",
+  "r"
+];
+var RESOLVER_SUITE_RUNNER_SET = new Set(RESOLVER_SUITE_RUNNERS);
+var RESOLVER_SUITE_RUNNER_LANGUAGES = Object.freeze(
+  Object.fromEntries(RESOLVER_SUITE_RUNNERS.map((runner) => [runner, runner]))
+);
+function isResolverSuiteRunner(runner) {
+  return typeof runner === "string" && RESOLVER_SUITE_RUNNER_SET.has(runner);
+}
+function detectResolverSuiteRunner(testCommands) {
+  for (const command of testCommands) {
+    const descriptor = describeVerificationCommand(command);
+    if (descriptor.kind !== "test") continue;
+    if (isResolverSuiteRunner(descriptor.language)) return descriptor.language;
+  }
+  return void 0;
+}
+function detectCommandTestRunner(command) {
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.kind !== "test") return null;
+  switch (descriptor.language) {
+    case "node": {
+      const normalized = command.trim().replace(/^(?:npx|pnpx|bunx)\s+(?:--no-install|--offline)\s+/u, "").replace(/^node\s+scripts\/dynamic-node-options\.mjs\s+/u, "").replace(/^(?:\.\/)?node_modules\/\.bin\//u, "");
+      const runner = normalized.match(/^(vitest|jest|mocha|ava)\b/)?.[1];
+      if (runner) return runner;
+      return /^node\s+(?:--[^\s]+\s+)*--test(?=\s|$)/u.test(normalized) ? "node-test" : null;
+    }
+    case "python":
+      return /\bpytest\b/u.test(command) ? "pytest" : /\bunittest\b/u.test(command) ? "unittest" : null;
+    case "go":
+      return "go";
+    case "rust":
+      return "cargo";
+    case "jvm":
+      return /\b(?:gradle|gradlew)\b/u.test(command) ? "gradle" : "maven";
+    default:
+      return isResolverSuiteRunner(descriptor.language) ? descriptor.language : null;
+  }
+}
+
+// src/core/judge/test-runner-summary-rows.ts
+var NAME_LIMIT = 20;
+function readPrintedCount(text, pattern) {
+  const value = pattern.exec(text)?.[1];
+  return value === void 0 ? void 0 : Number(value);
+}
+function readTestOutcomeTokens(summary, dialect) {
+  const boundary = dialect === "jest" ? String.raw`\b` : "";
+  const flags = dialect === "failure" ? "i" : "";
+  const count = (label) => readPrintedCount(summary, new RegExp(String.raw`(\d+)\s+${label}${boundary}`, flags));
+  return {
+    passed: count("passed"),
+    failed: count("failed"),
+    skipped: count("skipped"),
+    total: count("total")
+  };
+}
+function readTapFooterTokens(output, dialect) {
+  const count = (label) => {
+    const pattern = dialect === "node" ? new RegExp(String.raw`^[ \t]*# ${label} (\d+)[ \t]*$`, "m") : dialect === "judge" ? new RegExp(String.raw`^#\s+${label}\s+(\d+)\s*$`, "im") : new RegExp(String.raw`(?:^|\n)\s*#\s+${label}\s+(\d+)`, "i");
+    return readPrintedCount(output, pattern);
+  };
+  return {
+    tests: count("tests"),
+    pass: count("pass"),
+    fail: count("fail"),
+    cancelled: count("cancelled"),
+    skipped: count(dialect === "failure" ? "skip(?:ped)?" : "skipped"),
+    todo: count("todo")
+  };
+}
+function readPytestSummaryRows(output) {
+  const decorated = [];
+  const quiet = [];
+  const completeQuiet = /^\d+\s+[a-z]+(?:,\s*\d+\s+[a-z]+)*\s+in\s+\d+(?:\.\d+)?s(?:\s+\([\d:.]+\))?$/i;
+  for (const rawLine of stripAnsiSequences(output).split(/\r\n|[\r\n\u2028\u2029]/)) {
+    const line = rawLine.trim();
+    let start = 0;
+    while (start < line.length && line.charCodeAt(start) === 61) start += 1;
+    if (start > 0) {
+      let end = line.length - 1;
+      while (end >= start && line.charCodeAt(end) === 61) end -= 1;
+      if (end < line.length - 1) {
+        const summary = line.slice(start, end + 1).trim();
+        if (/\b\d+\s+(?:passed|failed|errors?|skipped)\b/i.test(summary)) {
+          decorated.push(summary);
+        }
+      }
+    } else if (/^(?:\d+\s+(?:passed|failed|errors?|warnings?|skipped|xfailed|xpassed|deselected)(?:,\s*|\s+in\b|$))+/i.test(
+      line
+    )) {
+      quiet.push(line);
+    }
+  }
+  const extraQuiet = decorated.length > 0 ? quiet.filter((line) => completeQuiet.test(line)) : quiet;
+  for (const summary of decorated) {
+    const duplicate = extraQuiet.indexOf(summary);
+    if (duplicate !== -1) extraQuiet.splice(duplicate, 1);
+  }
+  return [...decorated, ...extraQuiet].map((summary) => ({
+    passed: summary.match(/\b(\d+)\s+passed\b/i)?.[1] === void 0 ? void 0 : Number(summary.match(/\b(\d+)\s+passed\b/i)?.[1]),
+    failed: Number(summary.match(/\b(\d+)\s+failed\b/i)?.[1] ?? 0),
+    errors: Number(summary.match(/\b(\d+)\s+errors?\b/i)?.[1] ?? 0),
+    skipped: Number(summary.match(/\b(\d+)\s+skipped\b/i)?.[1] ?? 0)
+  }));
+}
+function lines(output) {
+  return stripAnsiSequences(output).split(/\r?\n/);
+}
+function uniqueNames(names, limit) {
+  return [...new Set(names)].slice(0, limit);
+}
+function readNodeSpecCounters(output) {
+  const cleaned = stripAnsiSequences(output);
+  const count = (label) => {
+    const match = cleaned.match(
+      new RegExp(String.raw`^\s*(?:\u2139\s+)?${label}\s+(\d+)\s*$`, "im")
+    )?.[1];
+    return match === void 0 ? void 0 : Number(match);
+  };
+  const tests = count("tests");
+  const pass = count("pass");
+  const fail = count("fail");
+  if (tests === void 0 || pass === void 0 || fail === void 0) return void 0;
+  if (!Number.isFinite(tests) || !Number.isFinite(pass) || !Number.isFinite(fail)) {
+    return void 0;
+  }
+  return {
+    tests,
+    pass,
+    fail,
+    cancelled: count("cancelled") ?? 0,
+    skipped: count("skipped") ?? 0,
+    todo: count("todo") ?? 0
+  };
+}
+function nodeSpecCountersAddUp(counters) {
+  const { tests, pass, fail, cancelled, skipped, todo } = counters;
+  return pass + fail + cancelled + skipped + todo === tests;
+}
+function readNodeSpecFailureNames(output, limit = NAME_LIMIT) {
+  const names = [];
+  for (const line of lines(output)) {
+    const match = /^\s*\u2716\s+(.+?)\s+\(\d+(?:\.\d+)?ms\)\s*$/.exec(line);
+    if (match?.[1]) names.push(match[1]);
+  }
+  return uniqueNames(names, limit);
+}
+function readMochaCounters(output) {
+  const cleaned = stripAnsiSequences(output);
+  const read = (pattern) => {
+    const match = cleaned.match(pattern)?.[1];
+    return match === void 0 ? void 0 : Number(match);
+  };
+  const passing = read(/^\s*(\d+)\s+passing(?:\s+\([^)\n]*\))?\s*$/m);
+  const failing = read(/^\s*(\d+)\s+failing\s*$/m);
+  if (passing === void 0 && failing === void 0) return void 0;
+  const pending = read(/^\s*(\d+)\s+pending\s*$/m);
+  return {
+    ...passing === void 0 ? {} : { passing },
+    ...failing === void 0 ? {} : { failing },
+    ...pending === void 0 ? {} : { pending }
+  };
+}
+function readMochaFailureNames(output, limit = NAME_LIMIT) {
+  const all = lines(output);
+  const start = all.findIndex((line) => /^\s*\d+\s+failing\s*$/.test(line));
+  if (start < 0) return [];
+  const names = [];
+  let index = start + 1;
+  while (index < all.length) {
+    const heading = /^\s*(\d+)\)\s+(.*\S)\s*$/.exec(all[index] ?? "");
+    if (!heading || Number(heading[1]) !== names.length + 1) {
+      index += 1;
+      continue;
+    }
+    const parts = [heading[2] ?? ""];
+    index += 1;
+    while (index < all.length && (all[index] ?? "").trim() !== "") {
+      parts.push((all[index] ?? "").trim());
+      index += 1;
+    }
+    names.push(parts.join(" ").replace(/:$/, ""));
+  }
+  return names.slice(0, limit);
+}
+function readAvaCounters(output) {
+  const cleaned = stripAnsiSequences(output);
+  const read = (pattern) => {
+    const match = cleaned.match(pattern)?.[1];
+    return match === void 0 ? void 0 : Number(match);
+  };
+  const passed = read(/^\s*(\d+)\s+tests?\s+passed\s*$/m);
+  const failed = read(/^\s*(\d+)\s+tests?\s+failed\s*$/m);
+  if (passed === void 0 && failed === void 0) return void 0;
+  return {
+    ...passed === void 0 ? {} : { passed },
+    ...failed === void 0 ? {} : { failed }
+  };
+}
+function readAvaFailureNames(output, limit = NAME_LIMIT) {
+  const names = [];
+  for (const line of lines(output)) {
+    const match = /^\s*\S+\s+\[fail\]:\s+(.+?)\s*$/.exec(line);
+    if (match?.[1]) names.push(match[1]);
+  }
+  return uniqueNames(names, limit);
+}
+function readBunCounters(output) {
+  const cleaned = stripAnsiSequences(output);
+  const read = (pattern) => {
+    const match = cleaned.match(pattern)?.[1];
+    return match === void 0 ? void 0 : Number(match);
+  };
+  const pass = read(/^\s*(\d+)\s+pass\s*$/m);
+  const fail = read(/^\s*(\d+)\s+fail\s*$/m);
+  const ran = read(/^Ran\s+(\d+)\s+tests?\s+across\s+\d+\s+files?\b/m);
+  if (pass === void 0 || fail === void 0 || ran === void 0) return void 0;
+  return {
+    pass,
+    fail,
+    skip: read(/^\s*(\d+)\s+skip\s*$/m) ?? 0,
+    todo: read(/^\s*(\d+)\s+todo\s*$/m) ?? 0,
+    ran
+  };
+}
+function bunCountersAddUp(counters) {
+  const { pass, fail, skip, todo, ran } = counters;
+  return pass + fail + skip + todo === ran;
+}
+function readBunFailureNames(output, limit = NAME_LIMIT) {
+  const names = [];
+  for (const line of lines(output)) {
+    const match = /^\(fail\)\s+(.+?)(?:\s+\[[\d.]+m?s\])?\s*$/.exec(line);
+    if (match?.[1]) names.push(match[1]);
+  }
+  return uniqueNames(names, limit);
+}
+function readCargoTestTotals(output) {
+  const results = Array.from(
+    stripAnsiSequences(output).matchAll(
+      /^\s*test result:\s+(ok|FAILED)\.\s+(\d+)\s+passed;\s+(\d+)\s+failed;(?:\s+(\d+)\s+ignored;)?/gim
+    )
+  );
+  if (results.length === 0) return void 0;
+  return results.reduce(
+    (total, match) => ({
+      passed: total.passed + Number(match[2] ?? 0),
+      failed: total.failed + Number(match[3] ?? 0),
+      ignored: total.ignored + Number(match[4] ?? 0),
+      summaries: total.summaries + 1,
+      failedSummaries: total.failedSummaries + (match[1]?.toUpperCase() === "FAILED" ? 1 : 0)
+    }),
+    { passed: 0, failed: 0, ignored: 0, summaries: 0, failedSummaries: 0 }
+  );
+}
+function readCargoFailureLines(output) {
+  const failed = [];
+  for (const line of lines(output)) {
+    if (/^test\s+\S+\s+\.\.\.\s+FAILED\b/.test(line.trim())) failed.push(line.trim());
+  }
+  return failed.slice(0, NAME_LIMIT);
+}
+function readSurefireTotals(output) {
+  let totals;
+  for (const line of lines(output)) {
+    const match = /^(?:\[[A-Z]+\]\s+)?Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+)(?:,\s*Skipped:\s*(\d+))?\s*$/.exec(
+      line
+    );
+    if (!match) continue;
+    totals ??= { run: 0, failures: 0, errors: 0, skipped: 0 };
+    totals.run += Number(match[1]);
+    totals.failures += Number(match[2]);
+    totals.errors += Number(match[3]);
+    totals.skipped += Number(match[4] ?? 0);
+  }
+  return totals;
+}
+function readXctestTotal(output) {
+  const all = lines(output);
+  for (let index = all.length - 1; index >= 0; index -= 1) {
+    const match = /^\s*Executed\s+(\d+)\s+tests?,\s+with\s+(\d+)\s+failures?\b/.exec(
+      all[index] ?? ""
+    );
+    if (match) return { run: Number(match[1]), failures: Number(match[2]) };
+  }
+  return void 0;
+}
+
+// src/core/judge/test-runner-summaries.ts
+function asMeasuredMetrics(metrics) {
+  const { testsRun, testsPassed, testsFailed } = metrics;
+  return { testsRun, testsPassed, testsFailed, metricsMeasured: testsRun > 0 };
+}
+function parseVitestOutput(output) {
+  const testMatch = lastMatch(
+    stripAnsiSequences(output),
+    /^\s*Tests\s+(.*\d+\s+(?:passed|failed).*?)\s*$/gm
+  );
+  if (testMatch) {
+    const summary = testMatch[1] ?? "";
+    const tokens = readTestOutcomeTokens(summary, "vitest");
+    const passed = tokens.passed ?? 0;
+    const failed = tokens.failed ?? 0;
+    return {
+      testsRun: passed + failed,
+      testsPassed: passed,
+      testsFailed: failed
+    };
+  }
+  return { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+}
+function parseJestOutput(output) {
+  const summaryMatch = output.match(/Tests:[ \t]+([^\n\r]*?\d+\s+total)/);
+  if (summaryMatch) {
+    const summary = summaryMatch[1] ?? "";
+    const tokens = readTestOutcomeTokens(summary, "jest");
+    return {
+      testsRun: tokens.total ?? 0,
+      testsPassed: tokens.passed ?? 0,
+      testsFailed: tokens.failed ?? 0
+    };
+  }
+  return { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+}
+function parseMochaStyleOutput(output) {
+  const mocha = readMochaCounters(output);
+  if (mocha) {
+    const passed = mocha.passing ?? 0;
+    const failed = mocha.failing ?? 0;
+    return { testsRun: passed + failed, testsPassed: passed, testsFailed: failed };
+  }
+  const ava = readAvaCounters(output);
+  if (ava) {
+    const passed = ava.passed ?? 0;
+    const failed = ava.failed ?? 0;
+    return { testsRun: passed + failed, testsPassed: passed, testsFailed: failed };
+  }
+  const tap = parseTapSummary(output);
+  if (tap) return tap;
+  return { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+}
+function parseTapSummary(output) {
+  const tokens = readTapFooterTokens(output, "judge");
+  const tapTests = tokens.tests;
+  if (tapTests !== void 0 && Number.isFinite(tapTests)) {
+    const tapPassed = tokens.pass ?? 0;
+    const tapFailed = tokens.fail ?? 0;
+    const tapCancelled = tokens.cancelled ?? 0;
+    return {
+      testsRun: tapTests,
+      testsPassed: tapPassed,
+      testsFailed: tapFailed + tapCancelled
+    };
+  }
+  const resultLines = output.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^(?:not\s+ok|ok)\s+\d+\b/i.test(line));
+  if (resultLines.length > 0) {
+    const failed = resultLines.filter((line) => /^not\s+ok\b/i.test(line)).length;
+    const passed = resultLines.length - failed;
+    return { testsRun: resultLines.length, testsPassed: passed, testsFailed: failed };
+  }
+  return void 0;
+}
+function parseUnittestOutput(output) {
+  const sumMatches = (pattern) => {
+    let total = 0;
+    for (const match of output.matchAll(pattern)) {
+      total += Number(match[1] ?? 0);
+    }
+    return total;
+  };
+  const testsRun = sumMatches(/^[ \t]*Ran[ \t]+(\d+)[ \t]+tests?\b/gim);
+  if (testsRun === 0) {
+    return { testsRun: 0, testsPassed: 0, testsFailed: 0, testsSkipped: 0 };
+  }
+  const outcomeMatches = Array.from(
+    output.matchAll(/^[ \t]*(?:OK|FAILED)\b[ \t]*(?:\(([^)]*)\))?[ \t]*$/gim)
+  );
+  const outcomeLines = outcomeMatches.map((match) => match[1] ?? "").join(", ");
+  const ranLineCount = Array.from(output.matchAll(/^[ \t]*Ran[ \t]+\d+[ \t]+tests?\b/gim)).length;
+  const countIn = (pattern) => {
+    let total = 0;
+    for (const match of outcomeLines.matchAll(pattern)) {
+      total += Number(match[1] ?? 0);
+    }
+    return total;
+  };
+  const failures = countIn(/(?<!\bexpected )failures=(\d+)/gi);
+  const errors = countIn(/\berrors=(\d+)/gi);
+  const unexpectedSuccesses = countIn(/\bunexpected\s+successes=(\d+)/gi);
+  const skipped = countIn(/\bskipped=(\d+)/gi);
+  const testsFailed = failures + errors + unexpectedSuccesses;
+  const testsPassed = Math.max(0, testsRun - testsFailed - skipped);
+  return {
+    testsRun,
+    testsPassed,
+    testsFailed,
+    testsSkipped: outcomeMatches.length >= ranLineCount ? skipped : null
+  };
+}
+function parsePytestOutput(output) {
+  const rows = readPytestSummaryRows(output);
+  const passed = rows.reduce((sum, row) => sum + (row.passed ?? 0), 0);
+  const failed = rows.reduce((sum, row) => sum + row.failed + row.errors, 0);
+  return { testsRun: passed + failed, testsPassed: passed, testsFailed: failed };
+}
+function parseNodeSpecSummary(output) {
+  const counters = readNodeSpecCounters(output);
+  if (!counters) return void 0;
+  return {
+    testsRun: counters.tests,
+    testsPassed: counters.pass,
+    testsFailed: counters.fail + counters.cancelled,
+    metricsMeasured: counters.tests > 0 && nodeSpecCountersAddUp(counters)
+  };
+}
+function lastMatch(output, pattern) {
+  return Array.from(output.matchAll(pattern)).at(-1);
+}
+function parseRustSummary(output) {
+  const totals = readCargoTestTotals(output);
+  if (!totals) return void 0;
+  const testsRun = totals.passed + totals.failed;
+  return {
+    testsRun,
+    testsPassed: totals.passed,
+    testsFailed: totals.failed,
+    metricsMeasured: testsRun > 0
+  };
+}
+function parseDotnetSummary(output) {
+  const summaries = Array.from(
+    output.matchAll(
+      /^\s*(?:Passed|Failed)!\s*-\s*Failed:\s*(\d+),\s*Passed:\s*(\d+),\s*Skipped:\s*(\d+),\s*Total:\s*(\d+)\b/gim
+    )
+  );
+  if (summaries.length > 0) {
+    const totals = summaries.reduce(
+      (acc, match) => ({
+        failed: acc.failed + Number(match[1] ?? 0),
+        passed: acc.passed + Number(match[2] ?? 0),
+        skipped: acc.skipped + Number(match[3] ?? 0),
+        total: acc.total + Number(match[4] ?? 0)
+      }),
+      { failed: 0, passed: 0, skipped: 0, total: 0 }
+    );
+    return {
+      testsRun: totals.passed + totals.failed,
+      testsPassed: totals.passed,
+      testsFailed: totals.failed,
+      metricsMeasured: totals.total > 0 && totals.passed + totals.failed + totals.skipped === totals.total
+    };
+  }
+  return void 0;
+}
+function parseRubySummary(output) {
+  const rspec = lastMatch(
+    output,
+    /^\s*(\d+)\s+examples?,\s+(\d+)\s+failures?(?:,\s+(\d+)\s+pending)?\s*$/gim
+  );
+  if (rspec) {
+    const testsRun = Number(rspec[1] ?? 0);
+    const testsFailed = Number(rspec[2] ?? 0);
+    const pending = Number(rspec[3] ?? 0);
+    return {
+      testsRun: Math.max(0, testsRun - pending),
+      testsPassed: Math.max(0, testsRun - testsFailed - pending),
+      testsFailed,
+      metricsMeasured: testsRun > 0 && testsFailed + pending <= testsRun
+    };
+  }
+  const minitest = lastMatch(
+    output,
+    /^\s*(\d+)\s+runs?,\s+\d+\s+assertions?,\s+(\d+)\s+failures?,\s+(\d+)\s+errors?,\s+(\d+)\s+skips?\s*$/gim
+  );
+  if (minitest) {
+    const testsRun = Number(minitest[1] ?? 0);
+    const testsFailed = Number(minitest[2] ?? 0) + Number(minitest[3] ?? 0);
+    const skipped = Number(minitest[4] ?? 0);
+    return {
+      testsRun: Math.max(0, testsRun - skipped),
+      testsPassed: Math.max(0, testsRun - testsFailed - skipped),
+      testsFailed,
+      metricsMeasured: testsRun > 0 && testsFailed + skipped <= testsRun
+    };
+  }
+  return void 0;
+}
+function parseDartSummary(output) {
+  const progress = lastMatch(output, /^\s*\d+:\d{2}\s+([+~\-\d\s]+?)(?::|\s*$)/gim);
+  if (progress) {
+    const counters = progress[1] ?? "";
+    const readCount = (prefix) => Number(counters.match(new RegExp(`${prefix}(\\d+)`))?.[1] ?? 0);
+    const testsPassed = readCount("\\+");
+    const testsFailed = readCount("-");
+    const testsRun = testsPassed + testsFailed;
+    return {
+      testsRun,
+      testsPassed,
+      testsFailed,
+      metricsMeasured: testsRun > 0
+    };
+  }
+  return void 0;
+}
+function parseSwiftSummary(output) {
+  const xctest = lastMatch(
+    output,
+    /^\s*Executed\s+(\d+)\s+tests?,\s+with\s+(\d+)\s+failures?\b/gim
+  );
+  const swiftTesting = lastMatch(
+    output,
+    /^[^A-Za-z0-9\r\n]*Test run with\s+(\d+)\s+tests?\s+passed\b/gim
+  );
+  if (xctest || swiftTesting) {
+    const xctestRun = Number(xctest?.[1] ?? 0);
+    const xctestFailed = Number(xctest?.[2] ?? 0);
+    const swiftTestingRun = Number(swiftTesting?.[1] ?? 0);
+    const testsRun = xctestRun + swiftTestingRun;
+    return {
+      testsRun,
+      testsPassed: Math.max(0, xctestRun - xctestFailed) + swiftTestingRun,
+      testsFailed: xctestFailed,
+      metricsMeasured: testsRun > 0 && xctestFailed <= xctestRun
+    };
+  }
+  return void 0;
+}
+function parsePhpSummary(output) {
+  const phpunit = lastMatch(output, /^\s*OK\s+\((\d+)\s+tests?,\s+\d+\s+assertions?\)\s*$/gim);
+  if (phpunit) {
+    const testsRun = Number(phpunit[1] ?? 0);
+    return {
+      testsRun,
+      testsPassed: testsRun,
+      testsFailed: 0,
+      metricsMeasured: testsRun > 0
+    };
+  }
+  const phpunitFailure = lastMatch(
+    output,
+    /^\s*Tests:\s*(\d+),\s*Assertions:\s*\d+(.*?)(?:\.\s*)?$/gim
+  );
+  if (phpunitFailure) {
+    const testsRun = Number(phpunitFailure[1] ?? 0);
+    const counters = /* @__PURE__ */ new Map();
+    for (const counter of (phpunitFailure[2] ?? "").matchAll(
+      /,\s*([A-Za-z][A-Za-z ]*):\s*(\d+)/g
+    )) {
+      counters.set(counter[1]?.trim().toLowerCase() ?? "", Number(counter[2] ?? 0));
+    }
+    const count = (name) => counters.get(name) ?? 0;
+    const testsFailed = count("failures") + count("errors") + count("risky") + count("incomplete");
+    const skipped = count("skipped");
+    const executed = Math.max(0, testsRun - skipped);
+    return {
+      testsRun: executed,
+      testsPassed: Math.max(0, executed - testsFailed),
+      testsFailed,
+      metricsMeasured: executed > 0 && testsFailed <= executed
+    };
+  }
+  return void 0;
+}
+function parseNativeSummary(output) {
+  const ctest = lastMatch(
+    output,
+    /^\s*\d+%\s+tests passed,\s+(\d+)\s+tests failed out of\s+(\d+)\s*$/gim
+  );
+  if (ctest) {
+    const testsFailed = Number(ctest[1] ?? 0);
+    const testsRun = Number(ctest[2] ?? 0);
+    return {
+      testsRun,
+      testsPassed: Math.max(0, testsRun - testsFailed),
+      testsFailed,
+      metricsMeasured: testsRun > 0 && testsFailed <= testsRun
+    };
+  }
+  const mesonCount = (label) => {
+    const match = lastMatch(output, new RegExp(String.raw`^\s*${label}:\s*(\d+)\s*$`, "gim"));
+    return match?.[1] === void 0 ? void 0 : Number(match[1]);
+  };
+  const passed = mesonCount("Ok");
+  const failed = mesonCount("Fail");
+  if (passed !== void 0 && failed !== void 0) {
+    const expectedFail = mesonCount("Expected Fail") ?? 0;
+    const unexpectedPass = mesonCount("Unexpected Pass") ?? 0;
+    const timedOut = mesonCount("Timeout") ?? 0;
+    const testsPassed = passed + expectedFail;
+    const testsFailed = failed + unexpectedPass + timedOut;
+    const testsRun = testsPassed + testsFailed;
+    return {
+      testsRun,
+      testsPassed,
+      testsFailed,
+      metricsMeasured: testsRun > 0
+    };
+  }
+  return void 0;
+}
+function parseRSummary(output) {
+  const testthat = lastMatch(
+    output,
+    /^\s*\[\s*FAIL\s+(\d+)\s*\|\s*WARN\s+\d+\s*\|\s*SKIP\s+(\d+)\s*\|\s*PASS\s+(\d+)\s*\]\s*$/gim
+  );
+  if (testthat) {
+    const testsFailed = Number(testthat[1] ?? 0);
+    const testsPassed = Number(testthat[3] ?? 0);
+    const testsRun = testsPassed + testsFailed;
+    return {
+      testsRun,
+      testsPassed,
+      testsFailed,
+      metricsMeasured: testsRun > 0
+    };
+  }
+  return void 0;
+}
+function parseSqlSummary(output) {
+  const dbt = lastMatch(
+    output,
+    /^\s*Done\.\s+PASS=(\d+)\s+WARN=(\d+)\s+ERROR=(\d+)\s+SKIP=(\d+)\s+TOTAL=(\d+)\s*$/gim
+  );
+  if (dbt) {
+    const testsPassed = Number(dbt[1] ?? 0);
+    const warned = Number(dbt[2] ?? 0);
+    const testsFailed = Number(dbt[3] ?? 0);
+    const skipped = Number(dbt[4] ?? 0);
+    const total = Number(dbt[5] ?? 0);
+    const testsRun = testsPassed + testsFailed;
+    return {
+      testsRun,
+      testsPassed,
+      testsFailed,
+      metricsMeasured: testsRun > 0 && testsPassed + warned + testsFailed + skipped === total
+    };
+  }
+  return void 0;
+}
+var LANGUAGE_SUMMARY_PARSERS = {
+  rust: parseRustSummary,
+  dotnet: parseDotnetSummary,
+  ruby: parseRubySummary,
+  dart: parseDartSummary,
+  swift: parseSwiftSummary,
+  php: parsePhpSummary,
+  native: parseNativeSummary,
+  r: parseRSummary,
+  sql: parseSqlSummary
+};
+function parseCommandFamilySummary(command, output) {
+  if (!command.trim()) return void 0;
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.kind !== "test") return void 0;
+  if (descriptor.language === "python") {
+    if (isPythonStdlibUnittestCommand(command)) {
+      return asMeasuredMetrics(parseUnittestOutput(output));
+    }
+    if (/\bpytest\b/.test(command)) {
+      return asMeasuredMetrics(parsePytestOutput(output));
+    }
+    return void 0;
+  }
+  if (descriptor.language === "node") return parseNodeRunnerSummary(output);
+  return LANGUAGE_SUMMARY_PARSERS[descriptor.language]?.(output);
+}
+function parseNodeRunnerSummary(output) {
+  const mochaStyle = asMeasuredMetrics(parseMochaStyleOutput(output));
+  if (mochaStyle.metricsMeasured) return mochaStyle;
+  const bun = readBunCounters(output);
+  if (!bun) return void 0;
+  const testsRun = bun.pass + bun.fail;
+  return {
+    testsRun,
+    testsPassed: bun.pass,
+    testsFailed: bun.fail,
+    metricsMeasured: testsRun > 0
+  };
+}
+function isOpaqueTestCommand(command) {
+  return command.trim() !== "" && describeVerificationCommand(command).language === "unknown";
+}
+var OPAQUE_WRAPPER_SUMMARY_PARSERS = [
+  (output) => asMeasuredMetrics(parsePytestOutput(output)),
+  (output) => asMeasuredMetrics(parseUnittestOutput(output)),
+  ...Object.values(LANGUAGE_SUMMARY_PARSERS),
+  (output) => asMeasuredMetrics(parseVitestOutput(output)),
+  (output) => asMeasuredMetrics(parseJestOutput(output)),
+  (output) => asMeasuredMetrics(parseMochaStyleOutput(output))
+];
+function parseOpaqueWrapperSummary(output) {
+  const totals = { testsRun: 0, testsPassed: 0, testsFailed: 0 };
+  for (const parse of OPAQUE_WRAPPER_SUMMARY_PARSERS) {
+    const metrics = parse(output);
+    if (!metrics || !metrics.metricsMeasured && metrics.testsFailed === 0) continue;
+    totals.testsRun += metrics.testsRun;
+    totals.testsPassed += metrics.testsPassed;
+    totals.testsFailed += metrics.testsFailed;
+  }
+  if (totals.testsFailed === 0 && totals.testsPassed === 0) return void 0;
+  return { ...totals, metricsMeasured: true };
+}
+function parseGenericPassFailOutput(rawOutput, command = "") {
+  const output = stripAnsiSequences(rawOutput);
+  const { failureProse, ...metrics } = readGenericPassFailOutput(output, command);
+  const proseOnlyFailure = failureProse === true;
+  if (metrics.metricsMeasured || metrics.testsFailed > 0 && !proseOnlyFailure || !isOpaqueTestCommand(command)) {
+    return metrics;
+  }
+  return parseOpaqueWrapperSummary(output) ?? metrics;
+}
+function readGenericPassFailOutput(output, command) {
+  const tap = parseTapSummary(output);
+  if (tap) {
+    return { ...tap, metricsMeasured: tap.testsRun > 0 };
+  }
+  const spec = parseNodeSpecSummary(output);
+  if (spec) {
+    return spec;
+  }
+  const familySummary = parseCommandFamilySummary(command, output);
+  if (familySummary) {
+    return familySummary;
+  }
+  const pester = output.match(
+    /Tests\s+Passed:\s*(\d+)\s*,\s*Failed:\s*(\d+)\s*,\s*Skipped:\s*(\d+)/i
+  );
+  if (pester) {
+    const passed = Number(pester[1] ?? 0);
+    const failed = Number(pester[2] ?? 0);
+    const skipped = Number(pester[3] ?? 0);
+    return {
+      testsRun: passed + failed + skipped,
+      testsPassed: passed,
+      testsFailed: failed,
+      metricsMeasured: passed + failed + skipped > 0
+    };
+  }
+  const surefire = readSurefireTotals(output);
+  if (surefire) {
+    const testsRun = surefire.run;
+    const testsFailed = surefire.failures + surefire.errors;
+    const skipped = surefire.skipped;
+    const executed = Math.max(0, testsRun - skipped);
+    return {
+      testsRun: executed,
+      testsPassed: Math.max(0, executed - testsFailed),
+      testsFailed,
+      metricsMeasured: executed > 0
+    };
+  }
+  const gradleCompleted = output.match(/(\d+)\s+tests?\s+completed\b/i);
+  if (gradleCompleted) {
+    const testsRun = Number(gradleCompleted[1] ?? 0);
+    const failedMatch = output.match(/(\d+)\s+failed\b/i);
+    const testsFailed = Number(failedMatch?.[1] ?? 0);
+    return {
+      testsRun,
+      testsPassed: Math.max(0, testsRun - testsFailed),
+      testsFailed,
+      metricsMeasured: testsRun > 0
+    };
+  }
+  const failureZeroStripped = output.replace(/\b(?:fail(?:ures?|ed)?|errors?)\s*[:=]\s*0\b/gi, "").replace(/\b0\s+(?:tests?\s+)?(?:failures?|failed|errors?)\b/gi, "").replace(/\u2139\s+fail\s+0\b/gi, "").replace(/\bfail\s+0\b/gi, "");
+  if (/\b(fail|failed|error)\b/i.test(failureZeroStripped)) {
+    return {
+      testsRun: 1,
+      testsPassed: 0,
+      testsFailed: 1,
+      metricsMeasured: false,
+      failureProse: true
+    };
+  }
+  const successProse = /\b(ok|pass|passed|test result: ok|BUILD SUCCESS|BUILD SUCCESSFUL)\b/i.test(
+    output
+  );
+  return {
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    metricsMeasured: false,
+    successProse
+  };
+}
+function parseTestOutput(runner, rawOutput, command = "") {
+  const output = rawOutput ? stripAnsiSequences(rawOutput) : rawOutput;
+  const fallback = {
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    metricsMeasured: false
+  };
+  if (!output) {
+    return fallback;
+  }
+  try {
+    const runnerParser = runner === "vitest" ? parseVitestOutput : runner === "jest" ? parseJestOutput : runner === "mocha" || runner === "ava" ? parseMochaStyleOutput : runner === "pytest" ? parsePytestOutput : runner === "unittest" ? parseUnittestOutput : void 0;
+    if (runnerParser) {
+      const metrics = asMeasuredMetrics(runnerParser(output));
+      if (!metrics.metricsMeasured && metrics.testsFailed === 0 && isOpaqueTestCommand(command)) {
+        return parseGenericPassFailOutput(output, command);
+      }
+      return metrics;
+    }
+    if (
+      // node:test emits TAP or (Node 24 default) spec; the generic parser
+      // reads both the TAP plan/trailer and the spec tests/pass/fail footer.
+      runner === "node-test" || runner === "go" || runner === "cargo" || runner === "maven" || runner === "gradle" || runner === "powershell" || runner === "generic" || // Resolver-lane suites (rspec/minitest, phpunit, dotnet test, swift test,
+      // dart test, ctest, R CMD check) are read by the command-family summary
+      // parser inside parseGenericPassFailOutput.
+      isResolverSuiteRunner(runner)
+    ) {
+      return parseGenericPassFailOutput(output, command);
+    }
+  } catch {
+    return fallback;
+  }
+  return fallback;
+}
+
+// src/core/project/test-execution-evidence.ts
+function readNodeTapCounters(output) {
+  const tokens = readTapFooterTokens(output, "node");
+  const { tests, pass, fail } = tokens;
+  if (tests === void 0 || pass === void 0 || fail === void 0) return void 0;
+  return {
+    tests,
+    pass,
+    fail,
+    cancelled: tokens.cancelled ?? 0,
+    skipped: tokens.skipped ?? 0,
+    todo: tokens.todo ?? 0
+  };
+}
+var VITEST_EXECUTED = /^[ \t]*(?:Tests[ \t]+(?:.* )?[1-9]\d* (?:passed|failed)|Test Files[ \t]+(?:.* )?[1-9]\d* failed)\b/m;
+var JEST_EXECUTED = /^(?:Tests:[ \t]+(?:.*, )?[1-9]\d* (?:passed|failed)|Test Suites:[ \t]+(?:.*, )?[1-9]\d* failed)\b/m;
+var PYTEST_SUMMARY = /^(?:=+ )?(\d+ [A-Za-z][A-Za-z ]*(?:, \d+ [A-Za-z][A-Za-z ]*)*) in \d+(?:\.\d+)?s(?: \(\d+:\d{2}:\d{2}\))?(?: =+)?[ \t]*$/gm;
+var PYTEST_NEUTRAL_PARTS = /* @__PURE__ */ new Set(["skipped", "deselected", "warning", "warnings"]);
+function readPytestSummaries(output) {
+  return Array.from(output.matchAll(PYTEST_SUMMARY), (match) => {
+    const summary = { executed: 0, skipped: 0 };
+    for (const part of (match[1] ?? "").split(", ")) {
+      const [count = "0", ...name] = part.split(" ");
+      const label = name.join(" ");
+      if (label === "skipped") summary.skipped += Number(count);
+      else if (!PYTEST_NEUTRAL_PARTS.has(label)) summary.executed += Number(count);
+    }
+    return summary;
+  });
+}
+function readUnittestTotals(output) {
+  const ran = Array.from(output.matchAll(/^Ran (\d+) tests? in [\d.]+s[ \t]*$/gm)).reduce(
+    (total, match) => total + Number(match[1] ?? 0),
+    0
+  );
+  const results = Array.from(output.matchAll(/^(?:OK|FAILED)\b.*$/gm), (match) => match[0].trim());
+  const skipCounts = results.map((line) => /^OK \(skipped=(\d+)\)$/.exec(line));
+  return {
+    ran,
+    skipped: skipCounts.reduce((total, match) => total + Number(match?.[1] ?? 0), 0),
+    skipOnly: results.length > 0 && skipCounts.every((match) => match !== null),
+    failed: /^FAILED\b/m.test(output)
+  };
+}
+var CARGO_RESULT = /^[ \t]*test result: (ok|FAILED)\. (\d+) passed; (\d+) failed; \d+ ignored; (\d+) measured; \d+ filtered out\b/gm;
+function readCargoResults(output) {
+  return Array.from(output.matchAll(CARGO_RESULT), (match) => ({
+    ok: match[1] === "ok",
+    executed: Number(match[2] ?? 0) + Number(match[3] ?? 0) + Number(match[4] ?? 0)
+  }));
+}
+var GO_EXECUTED_LINES = /^[ \t]*(?:--- (?:PASS|FAIL):|FAIL\b|panic:|Benchmark\S+[ \t]+\d+[ \t])/m;
+var GO_OK_LINE = /^ok[ \t]+\S+[ \t]+(?:\(cached\)|[\d.]+s)\b(?![^\n]*\[no tests to run\])/m;
+function goExecuted(output) {
+  if (GO_EXECUTED_LINES.test(output)) return true;
+  return GO_OK_LINE.test(output) && !/^[ \t]*--- SKIP:/m.test(output);
+}
+var DART_EXECUTED = /^\d{2,}:\d{2}[ \t]+(?:\+[1-9]\d*|(?:\+\d+[ \t]+)?-[1-9]\d*)\b/m;
+var SWIFT_EXECUTED = /^[ \t]*Executed [1-9]\d* tests?, with\b|^[^A-Za-z0-9\r\n]*Test run with [1-9]\d* tests?\b/m;
+var PESTER_EXECUTED = /^Tests Passed: (?:[1-9]\d*, Failed: \d+|\d+, Failed: [1-9]\d*)\b/m;
+var RSPEC_SUMMARY = /^[ \t]*(\d+) examples?, (\d+) failures?(?:, (\d+) pending)?(?:, (\d+) errors? occurred outside of examples)?[ \t]*$/gm;
+function readRspecSummaries(output) {
+  return Array.from(output.matchAll(RSPEC_SUMMARY), (match) => {
+    const [examples, failures, pending, errors] = match.slice(1).map((count) => Number(count ?? 0));
+    return {
+      examples: examples ?? 0,
+      executed: Math.max(0, (examples ?? 0) - (pending ?? 0)) + (failures ?? 0) + (errors ?? 0)
+    };
+  });
+}
+var MINITEST_SUMMARY = /^[ \t]*(\d+) runs?, \d+ assertions?, (\d+) failures?, (\d+) errors?, (\d+) skips?[ \t]*$/gm;
+function readMinitestSummaries(output) {
+  return Array.from(output.matchAll(MINITEST_SUMMARY), (match) => {
+    const [runs, failures, errors, skips] = match.slice(1).map(Number);
+    return {
+      runs: runs ?? 0,
+      executed: Math.max(0, (runs ?? 0) - (skips ?? 0)) + (failures ?? 0) + (errors ?? 0)
+    };
+  });
+}
+var MAVEN_RUN_LINE = /^[ \t]*(?:\[[A-Z]+\][ \t]*)?Tests run:[ \t]*(\d+),[ \t]*Failures:[ \t]*(\d+),[ \t]*Errors:[ \t]*(\d+)(?:,[ \t]*Skipped:[ \t]*(\d+))?/gm;
+function readMavenRunLines(output) {
+  return Array.from(output.matchAll(MAVEN_RUN_LINE), (match) => {
+    const [run, failures, errors, skipped] = match.slice(1).map((count) => Number(count ?? 0));
+    return {
+      skipped: skipped ?? 0,
+      executed: Math.max(0, (run ?? 0) - (skipped ?? 0)) + (failures ?? 0) + (errors ?? 0)
+    };
+  });
+}
+var DOTNET_SUMMARY = /^[ \t]*(Passed|Failed|Skipped)![ \t]*-[ \t]*Failed:[ \t]*(\d+),[ \t]*Passed:[ \t]*(\d+),[ \t]*Skipped:[ \t]*(\d+),[ \t]*Total:[ \t]*(\d+)\b/gm;
+function readDotnetSummaries(output) {
+  return Array.from(output.matchAll(DOTNET_SUMMARY), (match) => {
+    const [, outcome, failed, passed, skipped] = match;
+    const executed = Number(failed) + Number(passed);
+    return { skipped: Number(skipped), executed: outcome === "Failed" ? executed + 1 : executed };
+  });
+}
+function parsedRunnerRan(runner, output) {
+  const metrics = parseTestOutput(runner, output);
+  return metrics.testsPassed + metrics.testsFailed > 0;
+}
+var NODE_EXECUTED_LINE = /^[ \t]*(?:\u2139[ \t]+|# )?(?:pass|fail|cancelled)[ \t]+[1-9]\d*[ \t]*$/m;
+var MOCHA_EXECUTED_LINE = /^[ \t]*[1-9]\d*[ \t]+(?:passing(?:[ \t]+\([^)\n]*\))?|failing)[ \t]*$/m;
+var AVA_EXECUTED_LINE = /^[ \t]*[1-9]\d*[ \t]+tests?[ \t]+(?:passed|failed)[ \t]*$/m;
+var BUN_EXECUTED_LINE = /^[ \t]*[1-9]\d*[ \t]+(?:pass|fail)[ \t]*$/m;
+function outputProvesTestsRan(output) {
+  const plain = stripAnsiSequences(String(output ?? ""));
+  const nodeSummary = readNodeSpecCounters(plain) ?? readNodeTapCounters(plain);
+  if (nodeSummary && NODE_EXECUTED_LINE.test(plain)) return true;
+  if (readMochaCounters(plain) && MOCHA_EXECUTED_LINE.test(plain)) return true;
+  if (readAvaCounters(plain) && AVA_EXECUTED_LINE.test(plain)) return true;
+  if (readBunCounters(plain) && BUN_EXECUTED_LINE.test(plain)) return true;
+  if (VITEST_EXECUTED.test(plain) || JEST_EXECUTED.test(plain)) return true;
+  if (readPytestSummaries(plain).some((summary) => summary.executed > 0)) return true;
+  const unittest = readUnittestTotals(plain);
+  if (unittest.ran > unittest.skipped || unittest.failed) return true;
+  if (parsedRunnerRan("pytest", plain) || parsedRunnerRan("unittest", plain)) return true;
+  if (readCargoResults(plain).some((result) => !result.ok || result.executed > 0)) return true;
+  if (goExecuted(plain)) return true;
+  if (DART_EXECUTED.test(plain) || SWIFT_EXECUTED.test(plain) || PESTER_EXECUTED.test(plain)) {
+    return true;
+  }
+  if (readRspecSummaries(plain).some((summary) => summary.executed > 0)) return true;
+  if (readMinitestSummaries(plain).some((summary) => summary.executed > 0)) return true;
+  if (readMavenRunLines(plain).some((line) => line.executed > 0)) return true;
+  if (readDotnetSummaries(plain).some((summary) => summary.executed > 0)) return true;
+  return /^[1-9]\d* tests? completed\b/m.test(plain);
+}
+
+// src/core/project/zero-executed-runs.ts
+var VITEST_SKIP_ONLY = /^[ \t]*Tests[ \t]+[1-9]\d* (?:skipped|todo)(?: \| [1-9]\d* (?:skipped|todo))* \(\d+\)[ \t]*$/m;
+var JEST_SKIP_ONLY = /^Tests:[ \t]+[1-9]\d* (?:skipped|todo)(?:, [1-9]\d* (?:skipped|todo))*, \d+ total[ \t]*$/m;
+function pytestNothingExecuted(output) {
+  const summaries = readPytestSummaries(output);
+  return summaries.length > 0 && summaries.every((summary) => summary.executed === 0) && summaries.some((summary) => summary.skipped > 0);
+}
+function unittestNothingExecuted(output) {
+  const totals = readUnittestTotals(output);
+  return totals.skipOnly && totals.ran > 0 && totals.ran === totals.skipped;
+}
+function nodeCountersNothingExecuted(counters) {
+  return counters !== void 0 && counters.tests > 0 && counters.pass + counters.fail + counters.cancelled === 0;
+}
+var ZERO_EXECUTED_ROWS = [
+  {
+    runner: "vitest",
+    reason: "vitest ran only skipped or todo tests",
+    languages: ["node"],
+    nothingExecuted: (output) => VITEST_SKIP_ONLY.test(output)
+  },
+  {
+    runner: "jest",
+    reason: "jest ran only skipped or todo tests",
+    languages: ["node"],
+    nothingExecuted: (output) => JEST_SKIP_ONLY.test(output)
+  },
+  {
+    runner: "node-test",
+    reason: "node --test ran only skipped or todo tests",
+    languages: ["node"],
+    nothingExecuted: (output) => nodeCountersNothingExecuted(readNodeSpecCounters(output)) || nodeCountersNothingExecuted(readNodeTapCounters(output))
+  },
+  {
+    runner: "unittest",
+    reason: "unittest skipped every test",
+    languages: ["python"],
+    nothingExecuted: unittestNothingExecuted
+  },
+  {
+    runner: "pytest",
+    reason: "pytest skipped every test",
+    languages: ["python"],
+    nothingExecuted: pytestNothingExecuted
+  },
+  {
+    runner: "cargo",
+    reason: "cargo test executed no tests (all ignored or filtered out)",
+    languages: ["rust"],
+    nothingExecuted: (output) => {
+      const results = readCargoResults(output);
+      return results.length > 0 && results.every((result) => result.ok && result.executed === 0);
+    }
+  },
+  {
+    runner: "go",
+    reason: "go test skipped every test",
+    languages: ["go"],
+    nothingExecuted: (output) => /^[ \t]*--- SKIP:/m.test(output)
+  },
+  {
+    runner: "dart",
+    reason: "dart test skipped every test",
+    languages: ["dart"],
+    nothingExecuted: (output) => /^\d{2,}:\d{2}[ \t]+\+0(?:[ \t]+~\d+)?:[ \t]*All tests skipped\.[ \t]*$/m.test(output)
+  },
+  {
+    runner: "swiftpm",
+    reason: "swift test matched no test cases",
+    languages: ["swift"],
+    nothingExecuted: (output) => /^warning: No matching test cases were run[ \t]*$/m.test(output)
+  },
+  {
+    runner: "pester",
+    reason: "Invoke-Pester found no test files",
+    // Pester is not a classified runner: only an unclassified wrapper reaches this row.
+    languages: [],
+    nothingExecuted: (output) => /^(?:System\.Management\.Automation\.)?RuntimeException: No test files were found and no scriptblocks were provided\./m.test(
+      output
+    )
+  },
+  {
+    runner: "rspec",
+    reason: "rspec left every example pending",
+    languages: ["ruby"],
+    nothingExecuted: (output) => {
+      const summaries = readRspecSummaries(output);
+      return summaries.length > 0 && summaries.every((summary) => summary.examples > 0 && summary.executed === 0);
+    }
+  },
+  {
+    runner: "minitest",
+    reason: "minitest skipped every test",
+    languages: ["ruby"],
+    nothingExecuted: (output) => {
+      const summaries = readMinitestSummaries(output);
+      return summaries.length > 0 && summaries.every((summary) => summary.runs > 0 && summary.executed === 0);
+    }
+  },
+  {
+    runner: "maven",
+    reason: "maven surefire skipped every test",
+    languages: ["jvm"],
+    nothingExecuted: (output) => {
+      const lines2 = readMavenRunLines(output);
+      return lines2.length > 0 && lines2.every((line) => line.executed === 0) && lines2.some((line) => line.skipped > 0);
+    }
+  },
+  {
+    runner: "dotnet",
+    reason: "dotnet test skipped every test",
+    languages: ["dotnet"],
+    nothingExecuted: (output) => {
+      const summaries = readDotnetSummaries(output);
+      return summaries.length > 0 && summaries.every((summary) => summary.executed === 0) && summaries.some((summary) => summary.skipped > 0);
+    }
+  }
+];
+function rowApplies(row, command) {
+  return row.languages.length === 0 ? applicableRunnerLanguages(command) === "all" : row.languages.some((language) => runnerRowApplies(command, language));
+}
+function detectZeroExecutedRun(command, plainOutput, hint) {
+  const descriptor = describeVerificationCommand(command, hint);
+  if (descriptor.kind !== "test" && descriptor.kind !== "unknown") return void 0;
+  const row = ZERO_EXECUTED_ROWS.find(
+    (candidate) => rowApplies(candidate, descriptor) && candidate.nothingExecuted(plainOutput)
+  );
+  return row ? { runner: row.runner, reason: row.reason } : void 0;
+}
+
+// src/core/project/empty-run-exits.ts
+var ANSI_CSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
+var EMPTY_RUN_ROWS = [
+  {
+    runner: "jest",
+    reason: "jest found no tests",
+    languages: ["node"],
+    exitCodes: [1],
+    signatures: [/^[ \t]*No tests found, exiting with code 1[ \t]*$/m]
+  },
+  {
+    runner: "vitest",
+    reason: "vitest found no test files",
+    languages: ["node"],
+    exitCodes: [1],
+    signatures: [/^[ \t]*No test files found, exiting with code 1[ \t]*$/m]
+  },
+  {
+    runner: "mocha",
+    reason: "mocha found no test files",
+    languages: ["node"],
+    exitCodes: [1],
+    signatures: [/^[ \t]*Error: No test files found: ".*"[ \t]*$/m]
+  },
+  {
+    runner: "bun",
+    reason: "bun found no tests",
+    languages: ["node"],
+    exitCodes: [1],
+    signatures: [
+      /^error: 0 test files matching .+ in --cwd=".*"[ \t]*$/m,
+      /^error: regex ".*" matched 0 tests\. Searched \d+ files? \(skipping \d+ tests?\)/m
+    ]
+  },
+  {
+    runner: "ava",
+    reason: "ava found no test files",
+    languages: ["node"],
+    exitCodes: [1],
+    signatures: [/^[ \t]*(?:\u2718[ \t]+)?Couldn['’]t find any files to test[ \t]*$/m]
+  },
+  {
+    runner: "swiftpm",
+    reason: "SwiftPM found no tests",
+    languages: ["swift"],
+    exitCodes: [1],
+    signatures: [/^error: no tests found; create a target in the 'Tests' directory[ \t]*$/m]
+  },
+  {
+    runner: "maven",
+    reason: "Maven Surefire matched no tests",
+    languages: ["jvm"],
+    exitCodes: [1],
+    signatures: [
+      /^\[ERROR\] Failed to execute goal \S*surefire\S* .*No tests matching pattern ".*" were executed!/m
+    ]
+  },
+  {
+    runner: "gradle",
+    reason: "Gradle matched no tests",
+    languages: ["jvm"],
+    exitCodes: [1],
+    signatures: [/^> No tests found for given includes: \[.*\]\(--tests filter\)[ \t]*$/m]
+  },
+  {
+    runner: "dart",
+    reason: "dart test ran no tests",
+    languages: ["dart"],
+    exitCodes: [79],
+    signatures: [/^No tests ran\.[ \t]*\r?\n(?:No tests were found\.|No tests match )/m]
+  },
+  {
+    runner: "dart",
+    reason: "dart test found no test directory",
+    languages: ["dart"],
+    exitCodes: [65],
+    signatures: [
+      /^No test files were passed and the default "test\/" directory doesn't exist\.[ \t]*$/m
+    ]
+  },
+  {
+    runner: "unittest",
+    reason: "unittest ran no tests",
+    languages: ["python"],
+    exitCodes: [5],
+    signatures: [/^NO TESTS RAN[ \t]*$/m],
+    commandGate: isPythonStdlibUnittestCommand
+  }
+];
+var RUN_ERROR_LINES = [
+  /\berror TS\d+:/,
+  /\berror CS\d+:/,
+  /\berror\[E\d+\]/,
+  /^[ \t]*error: could not compile\b/m,
+  /:\d+(?::\d+)?: (?:fatal )?error:/,
+  /:\d+:\d+: Error:/,
+  /\bCOMPILATION (?:ERROR|FAILURE)\b/,
+  /^[ \t]*>?[ \t]*Task :\S*compile\S* FAILED\b/m,
+  /\[build failed\]/,
+  /^[ \t]*(?:Uncaught )?(?:SyntaxError|ReferenceError|TypeError|ImportError|ModuleNotFoundError)\b/m,
+  /\bCannot find module\b|\bERR_MODULE_NOT_FOUND\b|\bFailed to resolve import\b/,
+  /^[ \t]*Failed to load "/m
+];
+function matchedRow(row, descriptor, exitCode, output) {
+  if (!row.exitCodes.includes(exitCode)) return false;
+  if (!row.languages.some((language) => runnerRowApplies(descriptor, language))) return false;
+  const ownCommand = applicableRunnerLanguages(descriptor) !== "all";
+  if (ownCommand && row.commandGate && !row.commandGate(descriptor.command)) return false;
+  if (!row.signatures.some((signature) => signature.test(output))) return false;
+  return !RUN_ERROR_LINES.some((pattern) => pattern.test(output));
+}
+function detectEmptyRun(command, output, exitCode, hint) {
+  const plain = String(output ?? "").replace(ANSI_CSI, "");
+  if (exitCode === 0) {
+    if (detectZeroCollectedTests(command, output, hint)) {
+      return {
+        runner: "zero-collected",
+        reason: "zero collected",
+        message: "Test command exited 0 but collected/ran zero tests; no verification evidence."
+      };
+    }
+    const zeroExecuted = outputProvesTestsRan(plain) ? void 0 : detectZeroExecutedRun(command, plain, hint);
+    return zeroExecuted ? {
+      runner: zeroExecuted.runner,
+      reason: zeroExecuted.reason,
+      message: `Test command exited 0 but executed no tests (${zeroExecuted.reason}); no verification evidence.`
+    } : void 0;
+  }
+  const descriptor = describeVerificationCommand(command, hint);
+  if (descriptor.kind !== "test" && descriptor.kind !== "unknown") return void 0;
+  const row = outputProvesTestsRan(plain) ? void 0 : EMPTY_RUN_ROWS.find((candidate) => matchedRow(candidate, descriptor, exitCode, plain));
+  return row ? {
+    runner: row.runner,
+    reason: row.reason,
+    message: `Test command exited ${exitCode} having run no tests (${row.reason}); no verification evidence.`
+  } : void 0;
+}
+function detectEmptyRunOfResult(command, result, output, hint) {
+  if (typeof result.exitCode !== "number" || result.timedOut === true || result.isCanceled === true || result.isMaxBuffer === true) {
+    return void 0;
+  }
+  return detectEmptyRun(command, output, result.exitCode, hint);
+}
+
+// src/core/verification/verification-disposition.ts
+function deriveVerificationDisposition(input) {
+  const scope = input.scope ?? "unknown";
+  const uncovered = input.uncovered && input.uncovered.length > 0 ? input.uncovered : void 0;
+  const base = {
+    scope,
+    ...input.reason ? { reason: input.reason } : {},
+    ...uncovered ? { uncovered } : {}
+  };
+  if (!input.passed && !input.unavailable) return { outcome: "failed", ...base };
+  if (input.unavailable || uncovered) return { outcome: "unverified", ...base };
+  if (input.required === false) return { outcome: "not-required", ...base };
+  return { outcome: "passed", ...base };
+}
+function aggregateVerificationDispositions(entries, defaultScope = "unknown") {
+  const relevant = [];
+  for (const entry of entries) {
+    if (entry.verification) relevant.push(entry.verification);
+    else if (!entry.passed) relevant.push({ outcome: "failed", scope: defaultScope });
+  }
+  if (relevant.length === 0) return void 0;
+  const failed = relevant.find((d) => d.outcome === "failed");
+  if (failed) return failed;
+  const unverified = relevant.filter((d) => d.outcome === "unverified");
+  if (unverified.length > 0) {
+    const reasons = unverified.map((d) => d.reason).filter((r) => Boolean(r));
+    const uncovered = unverified.flatMap((d) => d.uncovered ?? []);
+    const scope = unverified.some((d) => d.scope === "project") ? "project" : unverified[0]?.scope ?? "unknown";
+    return {
+      outcome: "unverified",
+      scope,
+      ...reasons.length > 0 ? { reason: reasons.join("; ") } : {},
+      ...uncovered.length > 0 ? { uncovered } : {}
+    };
+  }
+  return relevant.find((d) => d.outcome === "passed") ?? relevant[0];
+}
+var SCOPE_TEXT = {
+  task: "this task",
+  project: "the project",
+  unknown: "an unknown scope"
+};
+function formatUnverifiedDeliveryLabel(disposition) {
+  if (disposition.outcome !== "unverified") return void 0;
+  const reason = disposition.reason?.trim().replace(/[.\s]+$/, "");
+  return `Delivered, unverified: tests for ${SCOPE_TEXT[disposition.scope]} were not verified; ${reason || "no verification result was available"}.`;
+}
+
+// src/core/verification/typescript-diagnostic-patterns.ts
+var LOCATION_PREFIX = {
+  parenthesized: /^(.+?)\((\d+),(\d+)\):/.source,
+  colon: /^(.+?):(\d+):(\d+)\s*-/.source
+};
+function createTypeScriptLocatedErrorPattern(location, options) {
+  return new RegExp(
+    LOCATION_PREFIX[location] + (options.locationWhitespace === "required" ? /\s+/.source : /\s*/.source) + /error\s+(TS\d+)/.source + (options.message === "required" ? /:\s*(.*)$/.source : ""),
+    options.multiline ? "gm" : ""
+  );
+}
+
+// src/core/project/biome-json-diagnostics.ts
+function extractBiomeJson(text) {
+  const raw = String(text ?? "").trim();
+  if (!raw) return null;
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  const candidate = raw.slice(start, end + 1);
+  try {
+    return { text: candidate, parsed: JSON.parse(candidate) };
+  } catch {
+    return null;
+  }
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readFile(location) {
+  const path = location.path;
+  const file = typeof path === "string" ? path : asRecord(path)?.file;
+  return typeof file === "string" && file.trim().length > 0 ? file : void 0;
+}
+function readPosition(location) {
+  const span = location.span;
+  const legacy = asRecord(asRecord(span)?.start) ?? asRecord(location.start);
+  if (legacy) {
+    return {
+      line: typeof legacy.line === "number" ? legacy.line : void 0,
+      column: typeof legacy.column === "number" ? legacy.column : void 0
+    };
+  }
+  const offset = Array.isArray(span) ? span[0] : void 0;
+  const source = location.sourceCode;
+  if (typeof offset !== "number" || offset < 0 || typeof source !== "string") return {};
+  const prefix = Buffer.from(source, "utf8").subarray(0, offset).toString("utf8");
+  const lastBreak = prefix.lastIndexOf("\n");
+  return { line: prefix.split("\n").length, column: prefix.length - lastBreak };
+}
+function readMessage(diag) {
+  if (typeof diag.description === "string" && diag.description) return diag.description;
+  const message = diag.message;
+  if (typeof message === "string") return message;
+  const text = asRecord(message)?.text;
+  if (typeof text === "string") return text;
+  if (Array.isArray(message)) {
+    const joined = message.map((part) => {
+      const content = asRecord(part)?.content;
+      return typeof content === "string" ? content : "";
+    }).join("");
+    return joined || void 0;
+  }
+  return void 0;
+}
+function readCategory(diag) {
+  for (const key of ["category", "code", "rule"]) {
+    const value = diag[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function readBiomeDiagnostics(parsed) {
+  const diagnostics = asRecord(parsed)?.diagnostics;
+  if (!Array.isArray(diagnostics)) return [];
+  const out = [];
+  for (const entry of diagnostics) {
+    const diag = asRecord(entry);
+    const location = asRecord(diag?.location);
+    if (!diag || !location) continue;
+    const file = readFile(location);
+    if (!file) continue;
+    const { line, column } = readPosition(location);
+    const tags = Array.isArray(diag.tags) ? diag.tags : [];
+    out.push({
+      file,
+      category: readCategory(diag),
+      severity: typeof diag.severity === "string" ? diag.severity : void 0,
+      message: readMessage(diag),
+      line,
+      column,
+      fixable: diag.canFix === true || tags.includes("fixable")
+    });
+  }
+  return out;
+}
+
+// src/core/verification/issue-identity.ts
+import { createHash } from "crypto";
+var IssueSet = class _IssueSet {
+  issues = /* @__PURE__ */ new Map();
+  /** Occurrence count per stable key (multiset cardinality of that signature). */
+  counts = /* @__PURE__ */ new Map();
+  constructor(issues) {
+    if (issues) {
+      for (const issue of issues) {
+        this.add(issue);
+      }
+    }
+  }
+  add(issue) {
+    this.issues.set(issue.key, issue);
+    this.counts.set(issue.key, (this.counts.get(issue.key) ?? 0) + 1);
+  }
+  /**
+   * Replace the representative issue for an existing key without changing
+   * occurrence count. Used by multi-command max-union so last-command wins for
+   * display fields and sentinel magnitude while counts stay max-of-counts.
+   */
+  setRepresentative(issue) {
+    if (!this.issues.has(issue.key)) return;
+    this.issues.set(issue.key, issue);
+  }
+  has(key) {
+    return this.issues.has(key);
+  }
+  get(key) {
+    return this.issues.get(key);
+  }
+  /**
+   * Occurrences of a stable key in this multiset (0 if absent).
+   * Minimal public surface for occurrence-aware comparison.
+   */
+  countOf(key) {
+    return this.counts.get(key) ?? 0;
+  }
+  /** Total occurrences across all stable keys (multiset cardinality). */
+  get size() {
+    let total = 0;
+    for (const n of this.counts.values()) {
+      total += n;
+    }
+    return total;
+  }
+  keys() {
+    return this.issues.keys();
+  }
+  values() {
+    return this.issues.values();
+  }
+  /** One representative issue per distinct stable key (not expanded by multiplicity). */
+  toArray() {
+    return Array.from(this.issues.values());
+  }
+  /**
+   * Multiset difference: occurrences in this set beyond those in other.
+   * Excess count for a shared key is reported as new/fixed occurrences.
+   */
+  difference(other) {
+    const result = new _IssueSet();
+    for (const issue of this.toArray()) {
+      const excess = this.countOf(issue.key) - other.countOf(issue.key);
+      for (let i = 0; i < excess; i++) {
+        result.add(issue);
+      }
+    }
+    return result;
+  }
+  /**
+   * Multiset intersection: min(count_this, count_other) per shared key.
+   */
+  intersection(other) {
+    const result = new _IssueSet();
+    for (const issue of this.toArray()) {
+      const shared = Math.min(this.countOf(issue.key), other.countOf(issue.key));
+      for (let i = 0; i < shared; i++) {
+        result.add(issue);
+      }
+    }
+    return result;
+  }
+};
+function normalizePath(filePath) {
+  let normalized = filePath.replace(/^\/Users\/[^/]+\/(?:[^/]+\/){1,5}/, "").replace(/^\/home\/[^/]+\/(?:[^/]+\/){1,5}/, "").replace(/^\/tmp\/(?:[^/]+\/){1,3}/, "").replace(/^C:\\Users\\[^\\]+\\(?:[^\\]+\\){1,5}/, "").replace(/^\.\//, "");
+  normalized = normalized.replace(/\\/g, "/");
+  return normalized;
+}
+function normalizeMessage(message) {
+  let normalized = message;
+  normalized = normalized.replace(/\bline\s+\d+/gi, "line <n>").replace(/\bcolumn\s+\d+/gi, "column <n>").replace(/\bat\s+\d+:\d+/gi, "at <n>:<n>").replace(/\(\d+,\s*\d+\)/g, "(<n>, <n>)").replace(/:\d+:\d+/g, ":<n>:<n>");
+  normalized = normalized.replace(/'[^']+'/g, "'<id>'").replace(/"[^"]+"/g, '"<id>"').replace(/`[^`]+`/g, "`<id>`").replace(/‘[^’]+’/g, "'<id>'").replace(/“[^”]+”/g, '"<id>"');
+  normalized = normalized.replace(/(?<!TS|ts)\b\d+\b/g, "<n>");
+  normalized = normalized.replace(/(?:\/[a-zA-Z0-9_.-]+)+(?:\.[a-zA-Z0-9]+)?/g, (match) => {
+    if (match.includes("/") && match.length > 5) {
+      return "<path>";
+    }
+    return match;
+  });
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  return normalized;
+}
+function hashMessage(normalizedMessage) {
+  return createHash("sha256").update(normalizedMessage).digest("hex").slice(0, 12);
+}
+function createKey(gate, file, code, messageHash) {
+  return `${gate}:${file}:${code}:${messageHash}`;
+}
+function createDiagnosticIssue(params) {
+  const file = normalizePath(params.filePath);
+  if (!isProjectSourcePath(file)) return null;
+  const code = params.code.trim() || "__diagnostic__";
+  const normalizedMsg = normalizeMessage(params.message);
+  const msgHash = hashMessage(normalizedMsg || code);
+  return {
+    gate: params.gate,
+    file,
+    code,
+    messageHash: msgHash,
+    key: createKey(params.gate, file, code, msgHash),
+    line: params.line,
+    col: params.col,
+    originalMessage: params.message
+  };
+}
+var DIAGNOSTIC_SEVERITY_LINE = /(?:^|[^a-z])(?:error|warning|failed|failure)\b/i;
+var DIAGNOSTIC_LOCATION_LINE = /(?:^|\s)\S+:\d+(?::\d+)?:/;
+var TRANSFER_NOISE_LINE = /^\s*(?:\[(?:INFO|DEBUG)\]\s*)?(?:Downloading|Downloaded|Download|Progress \(\d+\)|Fetching|Receiving|Resolving|Unpacking|Uploading|Uploaded)\b/i;
+function isTransferNoiseLine(line) {
+  return TRANSFER_NOISE_LINE.test(line);
+}
+function countUnparseableDiagnostics(output) {
+  if (!output) return 0;
+  let count = 0;
+  for (const rawLine of output.split(/\r?\n/)) {
+    if (isTransferNoiseLine(rawLine)) continue;
+    if (DIAGNOSTIC_SEVERITY_LINE.test(rawLine) || DIAGNOSTIC_LOCATION_LINE.test(rawLine)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function parseTypeScriptError(line) {
+  let match = createTypeScriptLocatedErrorPattern("parenthesized", {
+    message: "required",
+    locationWhitespace: "optional"
+  }).exec(line);
+  if (match) {
+    const filePath = match[1] ?? "";
+    const lineNum = match[2] ?? "0";
+    const colNum = match[3] ?? "0";
+    const code = match[4] ?? "";
+    const message = match[5];
+    const file = normalizePath(filePath);
+    const normalizedMsg = normalizeMessage(message ?? "");
+    const msgHash = hashMessage(normalizedMsg);
+    return {
+      gate: "build",
+      file,
+      code,
+      messageHash: msgHash,
+      key: createKey("build", file, code, msgHash),
+      line: Number.parseInt(lineNum, 10),
+      col: Number.parseInt(colNum, 10),
+      originalMessage: message
+    };
+  }
+  match = createTypeScriptLocatedErrorPattern("colon", {
+    message: "required",
+    locationWhitespace: "optional"
+  }).exec(line);
+  if (match) {
+    const filePath = match[1] ?? "";
+    const lineNum = match[2] ?? "0";
+    const colNum = match[3] ?? "0";
+    const code = match[4] ?? "";
+    const message = match[5];
+    const file = normalizePath(filePath);
+    const normalizedMsg = normalizeMessage(message ?? "");
+    const msgHash = hashMessage(normalizedMsg);
+    return {
+      gate: "build",
+      file,
+      code,
+      messageHash: msgHash,
+      key: createKey("build", file, code, msgHash),
+      line: Number.parseInt(lineNum, 10),
+      col: Number.parseInt(colNum, 10),
+      originalMessage: message
+    };
+  }
+  return null;
+}
+function parseLintError(filePath, ruleId, message, line, col) {
+  const file = normalizePath(filePath);
+  const normalizedMsg = message ? normalizeMessage(message) : "";
+  const msgHash = hashMessage(normalizedMsg || ruleId);
+  return {
+    gate: "lint",
+    file,
+    code: ruleId,
+    messageHash: msgHash,
+    key: createKey("lint", file, ruleId, msgHash),
+    line,
+    col,
+    originalMessage: message
+  };
+}
+function parseLintErrorLine(line) {
+  const match = /^(.+?):(\d+):(\d+)\s+(?:error|warning)\s+(.+?)\s+(\S+)\s*$/.exec(line);
+  if (match) {
+    const filePath = match[1] ?? "";
+    const lineNum = match[2] ?? "0";
+    const colNum = match[3] ?? "0";
+    const message = match[4];
+    const ruleId = match[5] ?? "";
+    return parseLintError(
+      filePath,
+      ruleId,
+      message,
+      Number.parseInt(lineNum, 10),
+      Number.parseInt(colNum, 10)
+    );
+  }
+  return null;
+}
+function parseBiomePrettyLine(line) {
+  if (/^\s/.test(line) || /\bat\s+\S/.test(line) || /\s-\s+error\s/.test(line)) {
+    return null;
+  }
+  const isLikelyPath = (filePath) => filePath.length > 0 && !/[{}[\]()"'`]/.test(filePath) && !filePath.includes("diagnostics") && !filePath.includes(" ");
+  const fullMatch = /^(.+?):(\d+):(\d+)\s+([a-z]+\/\S+)(?:\s|$)/.exec(line);
+  if (fullMatch) {
+    const filePath = fullMatch[1] ?? "";
+    if (!isLikelyPath(filePath)) return null;
+    const lineNum = Number.parseInt(fullMatch[2] ?? "0", 10);
+    const colNum = Number.parseInt(fullMatch[3] ?? "0", 10);
+    const ruleId = fullMatch[4] ?? "";
+    return parseLintError(filePath, ruleId, void 0, lineNum, colNum);
+  }
+  const truncatedMatch = /^([a-zA-Z0-9_./-]+):(\d+):(\d+)(?:\s+(\S+))?$/.exec(line);
+  if (truncatedMatch) {
+    const filePath = truncatedMatch[1] ?? "";
+    if (!isLikelyPath(filePath)) return null;
+    const lineNum = Number.parseInt(truncatedMatch[2] ?? "0", 10);
+    const colNum = Number.parseInt(truncatedMatch[3] ?? "0", 10);
+    const ruleIdCandidate = truncatedMatch[4] ?? "";
+    const ruleId = ruleIdCandidate.includes("/") ? ruleIdCandidate : "__biome_pretty_diagnostic__";
+    return parseLintError(filePath, ruleId, void 0, lineNum, colNum);
+  }
+  return null;
+}
+function parseTestFailure(testName, filePath, magnitude) {
+  const file = filePath ? normalizePath(filePath) : "";
+  const msgHash = hashMessage(testName);
+  return {
+    gate: "test",
+    file,
+    code: testName,
+    messageHash: msgHash,
+    key: createKey("test", file, testName, msgHash),
+    originalMessage: testName,
+    magnitude
+  };
+}
+function parseBuildFailure(marker, filePath, magnitude) {
+  const file = filePath ? normalizePath(filePath) : "";
+  const msgHash = hashMessage(marker);
+  return {
+    gate: "build",
+    file,
+    code: marker,
+    messageHash: msgHash,
+    key: createKey("build", file, marker, msgHash),
+    originalMessage: marker,
+    magnitude
+  };
+}
+function parseLintFailure(marker, filePath, magnitude) {
+  const file = filePath ? normalizePath(filePath) : "";
+  const msgHash = hashMessage(marker);
+  return {
+    gate: "lint",
+    file,
+    code: marker,
+    messageHash: msgHash,
+    key: createKey("lint", file, marker, msgHash),
+    originalMessage: marker,
+    magnitude
+  };
+}
+var UNPARSEABLE_BUILD_SENTINEL = "__unparseable_build_failures__";
+var UNPARSEABLE_LINT_SENTINEL = "__unparseable_lint_failures__";
+var UNPARSEABLE_TEST_SENTINEL = "__unparseable_test_failures__";
+function extractTypeScriptIssues(output) {
+  const issues = new IssueSet();
+  for (const line of output.split(/\r?\n/)) {
+    const issue = parseTypeScriptError(line.trim());
+    if (issue) {
+      issues.add(issue);
+    }
+  }
+  return issues;
+}
+function parseLocationDiagnosticLine(line, gate) {
+  const trimmed = line.trim();
+  const javaMatch = /^(.+?\.java):(\d+):\s*(error|warning):\s*(.+)$/.exec(trimmed);
+  if (javaMatch) {
+    return createDiagnosticIssue({
+      gate,
+      filePath: javaMatch[1] ?? "",
+      code: javaMatch[3] ?? "__java_diagnostic__",
+      message: javaMatch[4] ?? "",
+      line: Number.parseInt(javaMatch[2] ?? "0", 10)
+    });
+  }
+  const ruffOrMypyMatch = /^(.+?\.py):(\d+):(?:(\d+):)?\s*(?:(error|warning|[A-Z]\d{3,4}|[a-z][a-z0-9_-]+):\s*)?(.+)$/i.exec(
+    trimmed
+  );
+  if (ruffOrMypyMatch) {
+    const rawMessage = ruffOrMypyMatch[5] ?? "";
+    const inlineCode = /^([A-Z]\d{3,4})\s+(.+)$/.exec(rawMessage);
+    return createDiagnosticIssue({
+      gate,
+      filePath: ruffOrMypyMatch[1] ?? "",
+      code: ruffOrMypyMatch[4] ?? inlineCode?.[1] ?? "__python_diagnostic__",
+      message: inlineCode?.[2] ?? rawMessage,
+      line: Number.parseInt(ruffOrMypyMatch[2] ?? "0", 10),
+      col: ruffOrMypyMatch[3] ? Number.parseInt(ruffOrMypyMatch[3] ?? "0", 10) : void 0
+    });
+  }
+  const goMatch = /^(.+?\.go):(\d+):(?:(\d+):)?\s*(.+)$/.exec(trimmed);
+  if (goMatch) {
+    return createDiagnosticIssue({
+      gate,
+      filePath: goMatch[1] ?? "",
+      code: "__go_diagnostic__",
+      message: goMatch[4] ?? "",
+      line: Number.parseInt(goMatch[2] ?? "0", 10),
+      col: goMatch[3] ? Number.parseInt(goMatch[3] ?? "0", 10) : void 0
+    });
+  }
+  return null;
+}
+function extractRustDiagnostics(output, gate) {
+  const issues = new IssueSet();
+  let pending = null;
+  for (const rawLine of output.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+    const header = /^(?:error|warning)(?:\[(E\d+)\])?:\s*(.+)$/.exec(line.trim());
+    if (header) {
+      pending = {
+        code: header[1] ?? (line.trim().startsWith("warning") ? "__rust_warning__" : "__rust_error__"),
+        message: header[2] ?? ""
+      };
+      continue;
+    }
+    const location = /^\s*-->\s+(.+?\.rs):(\d+):(\d+)/.exec(line);
+    if (location && pending) {
+      const issue = createDiagnosticIssue({
+        gate,
+        filePath: location[1] ?? "",
+        code: pending.code,
+        message: pending.message,
+        line: Number.parseInt(location[2] ?? "0", 10),
+        col: Number.parseInt(location[3] ?? "0", 10)
+      });
+      if (issue) issues.add(issue);
+      pending = null;
+    }
+  }
+  return issues;
+}
+function extractLocationDiagnostics(output, gate) {
+  const issues = extractRustDiagnostics(output, gate);
+  for (const line of output.split(/\r?\n/)) {
+    const issue = parseLocationDiagnosticLine(line, gate);
+    if (issue) issues.add(issue);
+  }
+  return issues;
+}
+function extractNonNodeBuildIssues(output) {
+  return extractLocationDiagnostics(output, "build");
+}
+function extractNonNodeLintIssues(output) {
+  return extractLocationDiagnostics(output, "lint");
+}
+function extractBiomeLintIssues(output) {
+  const issues = new IssueSet();
+  const extracted = extractBiomeJson(output);
+  if (extracted) {
+    for (const diag of readBiomeDiagnostics(extracted.parsed)) {
+      issues.add(
+        parseLintError(diag.file, diag.category ?? "unknown", diag.message, diag.line, diag.column)
+      );
+    }
+  }
+  if (issues.size > 0) return issues;
+  for (const line of output.split(/\r?\n/)) {
+    const issue = parseLintErrorLine(line.trim());
+    if (issue) {
+      issues.add(issue);
+      continue;
+    }
+    const biomePretty = parseBiomePrettyLine(line.trim());
+    if (biomePretty) {
+      issues.add(biomePretty);
+    }
+  }
+  return issues;
+}
+function looksLikeProjectFileToken(token) {
+  const trimmed = token.trim();
+  if (trimmed.length === 0) return false;
+  if (isProjectSourcePath(trimmed)) return true;
+  return (trimmed.includes("/") || trimmed.includes("\\")) && !/\s/.test(trimmed);
+}
+function splitTestFailureId(testName) {
+  const trimmed = testName.trim();
+  for (const separator of [/\s*>\s*/, /::/]) {
+    const match = separator.exec(trimmed);
+    if (!match || match.index <= 0) continue;
+    const head = trimmed.slice(0, match.index).trim();
+    const tail = trimmed.slice(match.index + match[0].length).trim();
+    if (looksLikeProjectFileToken(head) && tail.length > 0) {
+      return { file: head, testPath: tail };
+    }
+  }
+  const goMatch = /^(.+?):(\d+)$/.exec(trimmed);
+  if (goMatch && looksLikeProjectFileToken(goMatch[1] ?? "")) {
+    return { file: (goMatch[1] ?? "").trim(), testPath: trimmed };
+  }
+  return { testPath: trimmed };
+}
+function extractTestFailures(failingTests, _testOutput) {
+  const issues = new IssueSet();
+  for (const testName of failingTests) {
+    const { file, testPath } = splitTestFailureId(testName);
+    issues.add(parseTestFailure(testPath, file));
+  }
+  return issues;
+}
+function calculateIssueDelta(baseline, current) {
+  const newIssues = current.difference(baseline);
+  const fixedIssues = baseline.difference(current);
+  const persistingIssues = current.intersection(baseline);
+  const regraded = new IssueSet();
+  const worsened = new IssueSet();
+  const improved = new IssueSet();
+  for (const issue of persistingIssues.toArray()) {
+    const n = persistingIssues.countOf(issue.key);
+    const baselineIssue = baseline.get(issue.key);
+    const currentMagnitude = issue.magnitude;
+    const baselineMagnitude = baselineIssue?.magnitude;
+    if (typeof currentMagnitude === "number" && typeof baselineMagnitude === "number") {
+      if (currentMagnitude > baselineMagnitude) {
+        for (let i = 0; i < n; i++) worsened.add(issue);
+        continue;
+      }
+      if (currentMagnitude < baselineMagnitude) {
+        for (let i = 0; i < n; i++) improved.add(baselineIssue ?? issue);
+        for (let i = 0; i < n; i++) regraded.add(issue);
+        continue;
+      }
+    }
+    for (let i = 0; i < n; i++) regraded.add(issue);
+  }
+  for (const issue of worsened.toArray()) {
+    for (let i = 0; i < worsened.countOf(issue.key); i++) newIssues.add(issue);
+  }
+  return {
+    newIssues,
+    fixedIssues,
+    persistingIssues: regraded,
+    netChange: fixedIssues.size - newIssues.size,
+    hasRegressions: newIssues.size > 0,
+    hasImprovements: fixedIssues.size > 0,
+    regradedImprovements: improved
+  };
+}
+function channelDidNotRun(status) {
+  return status === "skipped" || status === "unavailable" || status === "not_run";
+}
+function stableGateState(gate) {
+  const unavailable = gate?.status === "unavailable" || gate?.status === "not_run" || gate?.commandResults?.some((command) => command.status === "unavailable") === true;
+  const skipped = gate?.status === "skipped";
+  return {
+    passed: !unavailable && (skipped || gate?.exitCode === 0),
+    unavailable,
+    availability: unavailable ? "unavailable" : skipped ? "out_of_scope" : "executed"
+  };
+}
+function unparseableMarker(bare, language, multiCommand) {
+  if (!multiCommand || !language || language === "unknown") return bare;
+  return `${bare}:${language}`;
+}
+function buildIssuesFromSingleOutput(outputTail, language, multiCommand) {
+  const isNode = language === "node";
+  const parsed = isNode ? extractTypeScriptIssues(outputTail) : !language || language === "unknown" ? new IssueSet() : extractNonNodeBuildIssues(outputTail);
+  if (parsed.size > 0) return parsed;
+  const sentinel = new IssueSet();
+  sentinel.add(
+    parseBuildFailure(
+      unparseableMarker(UNPARSEABLE_BUILD_SENTINEL, language, multiCommand),
+      void 0,
+      countUnparseableDiagnostics(outputTail)
+    )
+  );
+  return sentinel;
+}
+function lintIssuesFromSingleOutput(outputTail, language, multiCommand) {
+  const isNode = language === "node";
+  const parsed = isNode ? extractBiomeLintIssues(outputTail) : !language || language === "unknown" ? new IssueSet() : extractNonNodeLintIssues(outputTail);
+  if (parsed.size > 0) return parsed;
+  const sentinel = new IssueSet();
+  sentinel.add(
+    parseLintFailure(
+      unparseableMarker(UNPARSEABLE_LINT_SENTINEL, language, multiCommand),
+      void 0,
+      countUnparseableDiagnostics(outputTail)
+    )
+  );
+  return sentinel;
+}
+function testIssuesFromSingleOutput(failingTests, outputTail, language, multiCommand) {
+  const extracted = extractTestFailures(failingTests, outputTail);
+  if (extracted.size > 0) return extracted;
+  const sentinel = new IssueSet();
+  sentinel.add(
+    parseTestFailure(
+      unparseableMarker(UNPARSEABLE_TEST_SENTINEL, language, multiCommand),
+      void 0,
+      countUnparseableDiagnostics(outputTail)
+    )
+  );
+  return sentinel;
+}
+function mergeCommandIssuesMaxUnion(into, from) {
+  for (const issue of from.toArray()) {
+    const deficit = from.countOf(issue.key) - into.countOf(issue.key);
+    if (deficit > 0) {
+      for (let i = 0; i < deficit; i++) {
+        into.add(issue);
+      }
+    } else if (into.has(issue.key)) {
+      into.setRepresentative(issue);
+    }
+  }
+}
+function issuesFromCommandResults(channel, commandResults, fallback) {
+  if (!commandResults || commandResults.length <= 1) return fallback();
+  const union = new IssueSet();
+  for (const command of commandResults) {
+    if (command.exitCode === 0 || channelDidNotRun(command.status)) continue;
+    const commandIssues = channel === "build" ? buildIssuesFromSingleOutput(command.outputTail, command.language, true) : channel === "lint" ? lintIssuesFromSingleOutput(command.outputTail, command.language, true) : testIssuesFromSingleOutput(
+      command.failingTestIdentities ?? command.failingTests ?? [],
+      command.outputTail,
+      command.language,
+      true
+    );
+    mergeCommandIssuesMaxUnion(union, commandIssues);
+  }
+  return union;
+}
+function extractStableVerificationState(gates) {
+  const buildOutputTail = gates.build?.outputTail ?? "";
+  const buildOutputLines = buildOutputTail.split(/\r?\n/).length;
+  const buildIssues = (() => {
+    if (gates.build == null) return new IssueSet();
+    return issuesFromCommandResults("build", gates.build.commandResults, () => {
+      if (gates.build == null || gates.build.exitCode === 0) return new IssueSet();
+      if (channelDidNotRun(gates.build.status)) return new IssueSet();
+      return buildIssuesFromSingleOutput(buildOutputTail, gates.build.language, false);
+    });
+  })();
+  const lintIssues = (() => {
+    if (gates.lint == null) return new IssueSet();
+    return issuesFromCommandResults("lint", gates.lint.commandResults, () => {
+      if (gates.lint == null || gates.lint.exitCode === 0) return new IssueSet();
+      if (channelDidNotRun(gates.lint.status)) return new IssueSet();
+      return lintIssuesFromSingleOutput(gates.lint.outputTail ?? "", gates.lint.language, false);
+    });
+  })();
+  const testIssues = (() => {
+    if (!gates.tests) return new IssueSet();
+    return issuesFromCommandResults("test", gates.tests.commandResults, () => {
+      if (!gates.tests) return new IssueSet();
+      if (gates.tests.status === "skipped" || gates.tests.status === "unavailable" || gates.tests.status === "not_run")
+        return new IssueSet();
+      if (gates.tests.exitCode === 0) return new IssueSet();
+      return testIssuesFromSingleOutput(
+        gates.tests.failingTestIdentities ?? gates.tests.failingTests ?? [],
+        gates.tests.outputTail ?? "",
+        gates.tests.language,
+        false
+      );
+    });
+  })();
+  const buildIncomplete = gates.build?.exitCode !== 0 && buildOutputTail.trim().length > 0 && buildOutputLines < 5;
+  return {
+    buildIssues,
+    lintIssues,
+    testIssues,
+    totalIssues: buildIssues.size + lintIssues.size + testIssues.size,
+    gates: {
+      build: {
+        ...stableGateState(gates.build),
+        incomplete: buildIncomplete
+      },
+      lint: stableGateState(gates.lint),
+      test: gates.tests ? stableGateState(gates.tests) : { passed: true, unavailable: true }
+    }
+  };
+}
+function compareVerificationStates(baseline, current) {
+  const build = calculateIssueDelta(baseline.buildIssues, current.buildIssues);
+  const lint = calculateIssueDelta(baseline.lintIssues, current.lintIssues);
+  const test = calculateIssueDelta(baseline.testIssues, current.testIssues);
+  const totalNewIssues = build.newIssues.size + lint.newIssues.size + test.newIssues.size;
+  const totalFixedIssues = build.fixedIssues.size + lint.fixedIssues.size + test.fixedIssues.size;
+  const totalPersistingIssues = build.persistingIssues.size + lint.persistingIssues.size + test.persistingIssues.size;
+  let incompleteOutputWarning;
+  if (current.gates.build.incomplete) {
+    incompleteOutputWarning = "Build output may be incomplete (tsc bailed early); delta accuracy reduced";
+  }
+  return {
+    build,
+    lint,
+    test,
+    totalNewIssues,
+    totalFixedIssues,
+    totalPersistingIssues,
+    hasAnyRegressions: build.hasRegressions || lint.hasRegressions || test.hasRegressions,
+    hasAnyImprovements: build.hasImprovements || lint.hasImprovements || test.hasImprovements,
+    netChange: totalFixedIssues - totalNewIssues,
+    incompleteOutputWarning
+  };
+}
+
+export {
+  selectBestErrorSummary,
+  normalizeOutput,
+  processOutput,
+  chunkToText,
+  createLineBufferedStreamProcessor,
+  stripAnsiSequences,
+  detectResolverSuiteRunner,
+  detectCommandTestRunner,
+  readTestOutcomeTokens,
+  readTapFooterTokens,
+  readPytestSummaryRows,
+  readNodeSpecCounters,
+  nodeSpecCountersAddUp,
+  readNodeSpecFailureNames,
+  readMochaCounters,
+  readMochaFailureNames,
+  readAvaCounters,
+  readAvaFailureNames,
+  readBunCounters,
+  bunCountersAddUp,
+  readBunFailureNames,
+  readCargoTestTotals,
+  readCargoFailureLines,
+  readSurefireTotals,
+  readXctestTotal,
+  parseUnittestOutput,
+  parseGenericPassFailOutput,
+  parseTestOutput,
+  detectEmptyRun,
+  detectEmptyRunOfResult,
+  deriveVerificationDisposition,
+  aggregateVerificationDispositions,
+  formatUnverifiedDeliveryLabel,
+  extractBiomeJson,
+  readBiomeDiagnostics,
+  createTypeScriptLocatedErrorPattern,
+  IssueSet,
+  isTransferNoiseLine,
+  countUnparseableDiagnostics,
+  parseTestFailure,
+  parseBuildFailure,
+  parseLintFailure,
+  UNPARSEABLE_BUILD_SENTINEL,
+  UNPARSEABLE_LINT_SENTINEL,
+  UNPARSEABLE_TEST_SENTINEL,
+  extractTypeScriptIssues,
+  extractBiomeLintIssues,
+  splitTestFailureId,
+  extractTestFailures,
+  extractStableVerificationState,
+  compareVerificationStates
+};
+//# sourceMappingURL=chunk-TUQMMFEQ.js.map