@poetic-ai/poetic 1.42.0

package/dist/chunk-WIRN3F75.js

@@ -0,0 +1,736 @@
+import {
+  isProjectSourcePath
+} from "./chunk-UDMS5AD3.js";
+import {
+  describeVerificationCommand
+} from "./chunk-2QLYTVYX.js";
+
+// 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+)?:/;
+function countUnparseableDiagnostics(output) {
+  if (!output) return 0;
+  let count = 0;
+  for (const rawLine of output.split(/\r?\n/)) {
+    if (DIAGNOSTIC_SEVERITY_LINE.test(rawLine) || DIAGNOSTIC_LOCATION_LINE.test(rawLine)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function parseTypeScriptError(line) {
+  let match = /^(.+?)\((\d+),(\d+)\):\s*error\s+(TS\d+):\s*(.*)$/.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 = /^(.+?):(\d+):(\d+)\s*-\s*error\s+(TS\d+):\s*(.*)$/.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 raw = output.trim();
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    const jsonCandidate = raw.slice(start, end + 1);
+    try {
+      const json = JSON.parse(jsonCandidate);
+      const diagnostics = Array.isArray(json?.diagnostics) ? json.diagnostics : [];
+      for (const diag of diagnostics) {
+        const filePath = diag?.location?.path;
+        if (typeof filePath !== "string" || !filePath.trim()) continue;
+        const ruleId = typeof diag?.category === "string" ? diag.category : typeof diag?.code === "string" ? diag.code : typeof diag?.rule === "string" ? diag.rule : "unknown";
+        const message = typeof diag?.message === "string" ? diag.message : typeof diag?.message?.text === "string" ? diag.message.text : void 0;
+        const line = diag?.location?.start?.line;
+        const col = diag?.location?.start?.column;
+        issues.add(
+          parseLintError(
+            filePath,
+            ruleId,
+            message,
+            typeof line === "number" ? line : void 0,
+            typeof col === "number" ? col : void 0
+          )
+        );
+      }
+    } catch {
+    }
+  }
+  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);
+        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);
+  }
+  for (const issue of improved.toArray()) {
+    for (let i = 0; i < improved.countOf(issue.key); i++) fixedIssues.add(issue);
+  }
+  return {
+    newIssues,
+    fixedIssues,
+    persistingIssues: regraded,
+    netChange: fixedIssues.size - newIssues.size,
+    hasRegressions: newIssues.size > 0,
+    hasImprovements: fixedIssues.size > 0
+  };
+}
+function channelDidNotRun(status) {
+  return status === "skipped" || status === "unavailable" || status === "not_run";
+}
+function unparseableMarker(bare, language, multiCommand) {
+  if (!multiCommand || !language || language === "unknown") return bare;
+  return `${bare}:${language}`;
+}
+function buildIssuesFromSingleOutput(outputTail, language, multiCommand) {
+  const isNode = (language ?? "node") === "node";
+  const parsed = isNode ? extractTypeScriptIssues(outputTail) : 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") === "node";
+  const parsed = isNode ? extractBiomeLintIssues(outputTail) : 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.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.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: {
+      // A build/lint that DID NOT RUN (out-of-scope / tool unavailable) is not failing
+      // — treat `passed` permissively, symmetric with the test channel, so a non-zero
+      // exit from a did-not-run channel is not read as a regression.
+      build: {
+        passed: gates.build?.exitCode === 0 || channelDidNotRun(gates.build?.status),
+        incomplete: buildIncomplete
+      },
+      lint: { passed: gates.lint?.exitCode === 0 || channelDidNotRun(gates.lint?.status) },
+      test: {
+        // `passed` stays permissive (a missing/skipped test gate is not a
+        // regression), but `unavailable` records that no actual test run
+        // produced this status so consumers can avoid treating it as verified.
+        passed: gates.tests == null || gates.tests.exitCode === 0 || gates.tests.status === "skipped" || gates.tests.status === "unavailable" || gates.tests.status === "not_run",
+        unavailable: gates.tests == null || gates.tests.status === "skipped" || gates.tests.status === "unavailable" || gates.tests.status === "not_run"
+      }
+    }
+  };
+}
+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
+  };
+}
+
+// src/core/project/parse-verification-errors.ts
+function channelForKind(kind) {
+  if (kind === "test") return "test";
+  if (kind === "lint" || kind === "format") return "lint";
+  return "build";
+}
+function parseVerificationErrors(descriptor, output, failed, failingTests = []) {
+  const channel = channelForKind(descriptor.kind);
+  const isNode = descriptor.language === "node";
+  if (channel === "test") {
+    const structured2 = extractTestFailures(failingTests, output);
+    if (structured2.size > 0) {
+      return { channel, issues: structured2, parsed: true };
+    }
+    if (failed) {
+      structured2.add(
+        parseTestFailure(UNPARSEABLE_TEST_SENTINEL, void 0, countUnparseableDiagnostics(output))
+      );
+      return { channel, issues: structured2, parsed: false };
+    }
+    return { channel, issues: structured2, parsed: true };
+  }
+  if (channel === "lint") {
+    const structured2 = isNode ? extractBiomeLintIssues(output) : extractBiomeLintIssues("");
+    if (structured2.size > 0) {
+      return { channel, issues: structured2, parsed: true };
+    }
+    if (failed) {
+      structured2.add(
+        parseLintFailure(UNPARSEABLE_LINT_SENTINEL, void 0, countUnparseableDiagnostics(output))
+      );
+      return { channel, issues: structured2, parsed: false };
+    }
+    return { channel, issues: structured2, parsed: true };
+  }
+  const structured = isNode ? extractTypeScriptIssues(output) : extractTypeScriptIssues("");
+  if (structured.size > 0) {
+    return { channel, issues: structured, parsed: true };
+  }
+  if (failed) {
+    structured.add(
+      parseBuildFailure(UNPARSEABLE_BUILD_SENTINEL, void 0, countUnparseableDiagnostics(output))
+    );
+    return { channel, issues: structured, parsed: false };
+  }
+  return { channel, issues: structured, parsed: true };
+}
+function parseVerificationErrorsForCommand(command, output, failed, failingTests = []) {
+  return parseVerificationErrors(
+    describeVerificationCommand(command),
+    output,
+    failed,
+    failingTests
+  );
+}
+var CHANNEL_KIND = {
+  build: "build",
+  lint: "lint",
+  test: "test"
+};
+function parseVerificationErrorsForChannel(channel, language, output, failed, failingTests = []) {
+  const descriptor = {
+    command: "",
+    language,
+    kind: CHANNEL_KIND[channel],
+    scope: "unknown",
+    costClass: "unknown"
+  };
+  return parseVerificationErrors(descriptor, output, failed, failingTests);
+}
+
+export {
+  splitTestFailureId,
+  extractStableVerificationState,
+  compareVerificationStates,
+  parseVerificationErrorsForCommand,
+  parseVerificationErrorsForChannel
+};
+//# sourceMappingURL=chunk-WIRN3F75.js.map