@herbertgao/pi-extensions 2026.9.14 → 2026.9.16

package/node_modules/pi-lens/dist/clients/dispatch/runners/cue-vet.js

@@ -104,6 +104,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { pathsEqual } from "../../path-utils.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
 import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
@@ -205,10 +206,24 @@ export function hasPackageClause(content) {
     }
     return false;
 }
-/** `.\bad.cue`, `./bad.cue`, and `bad.cue` all name the same file. */
-function locationMatchesFile(location, fileName) {
-    const normalized = location.file.replace(/\\/g, "/").replace(/^\.\//, "");
-    return path.posix.basename(normalized) === fileName;
+/**
+ * Is this reported location about the file we dispatched for? ONE seam answers
+ * that for every runner (#3278): resolve the tool's spelling against the cwd
+ * the tool RAN in and compare through `pathsEqual`.
+ *
+ * `cue` prints every position relative to its own cwd and prefixes a `./` when
+ * the result does not already start with a dot (`cue/errors/errors.go:586-596`
+ * at v0.11.0: `filepath.Rel(cfg.Cwd, s)`), which is why `.\bad.cue`,
+ * `./bad.cue` and `bad.cue` all name the vetted file — `pathsEqual` folds the
+ * separator and the `.` segment, so all three still match.
+ *
+ * What the basename compare this replaces could not do is tell those apart
+ * from `./sub/bad.cue` or `../lib/bad.cue`: an imported package's file that
+ * merely SHARES the touched file's basename was reported as the touched file's
+ * own failure (the over-merge direction, #3278 sub-shape C).
+ */
+function locationMatchesFile(location, absTarget, vetCwd) {
+    return pathsEqual(path.resolve(vetCwd, location.file), absTarget);
 }
 function toDiagnostic(id, message, fileName, line, column) {
     return {
@@ -252,16 +267,19 @@ function toDiagnostic(id, message, fileName, line, column) {
  * whole-output fallback message is used instead of one row per parsed
  * header.
  */
-export function filterToTouchedFile(errors, fileName) {
+export function filterToTouchedFile(errors, fileName, vetCwd) {
     if (errors.length === 0)
         return undefined;
+    // `cue vet` always runs in the touched file's own directory, so the vet cwd
+    // joined with the bare file name IS the dispatched file.
+    const absTarget = path.resolve(vetCwd, fileName);
     const withLocation = errors.filter((error) => error.locations.length > 0);
     const unattributable = errors.filter((error) => error.locations.length === 0);
     if (withLocation.length === 0)
         return undefined;
     const diagnostics = [];
     for (const error of withLocation) {
-        const match = error.locations.find((location) => locationMatchesFile(location, fileName));
+        const match = error.locations.find((location) => locationMatchesFile(location, absTarget, vetCwd));
         if (!match)
             continue; // sibling-only finding — surfaces when that file is touched
         diagnostics.push(toDiagnostic(`cue-vet-${diagnostics.length + 1}-${match.line}`, error.message, fileName, match.line, match.column));
@@ -364,7 +382,7 @@ const cueVetRunner = {
         // the directory-scoped path — one code path, and a single-file run
         // that somehow fails with no location at all still gets the same
         // never-silently-clean `undefined` fallback as the directory path.
-        const filtered = filterToTouchedFile(errors, fileName);
+        const filtered = filterToTouchedFile(errors, fileName, fileDir);
         if (filtered === undefined) {
             // Nonzero exit, some output, but nothing in it could be attributed to
             // ANY file — a real failure must not present as zero findings.

package/node_modules/pi-lens/dist/clients/dispatch/runners/dart-analyze.js

@@ -1,7 +1,9 @@
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { pathsEqual } from "../../path-utils.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 import { PRIORITY } from "../priorities.js";
 const dart = createAvailabilityChecker("dart", ".exe");
 const flutter = createAvailabilityChecker("flutter", ".bat");
@@ -94,8 +96,9 @@ const DART_FIXABLE_RULES = new Set([
 ]);
 // dart analyze --format=machine output:
 // severity|type|code|file|line|col|length|message
-function parseDartMachineOutput(raw, filePath) {
+function parseDartMachineOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split(/\r?\n/)) {
         if (!line.trim())
             continue;
@@ -106,14 +109,16 @@ function parseDartMachineOutput(raw, filePath) {
         const message = messageParts.join("|").trim();
         const lineNum = parseInt(lineStr, 10);
         const colNum = parseInt(colStr, 10);
-        // Only include diagnostics for the target file
-        if (file &&
-            !path.resolve(file).endsWith(path.resolve(filePath).replace(/\\/g, "/"))) {
-            const resolvedFile = path.resolve(file.trim());
-            const resolvedTarget = path.resolve(filePath);
-            if (resolvedFile !== resolvedTarget)
-                continue;
-        }
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        // The `endsWith` outer arm this replaces was inert on the target (a
+        // string ends with itself) and an over-merge risk everywhere else: any
+        // reported path whose TAIL spelled the absolute target attached to it.
+        // `file` is `parts[3]`, which `tsconfig.strict-indexed.json`
+        // (`noUncheckedIndexedAccess`) types as `string | undefined` even behind the
+        // `parts.length < 8` guard above — the strictness ratchet pins that, so the
+        // optional chain stays.
+        if (!pathsEqual(path.resolve(cwd, file?.trim() ?? ""), absTarget))
+            continue;
         const severity = severityStr?.trim().toLowerCase() === "error" ? "error" : "warning";
         const ruleId = code?.trim() ?? "dart";
         const fixable = DART_FIXABLE_RULES.has(ruleId);
@@ -136,12 +141,6 @@ function parseDartMachineOutput(raw, filePath) {
     }
     return diagnostics;
 }
-function firstOutputLine(result) {
-    return `${result.stderr || ""}\n${result.stdout || ""}`
-        .trim()
-        .split(/\r?\n/, 1)[0]
-        .slice(0, 200);
-}
 const dartAnalyzeRunner = {
     id: "dart-analyze",
     appliesTo: ["dart"],
@@ -162,40 +161,22 @@ const dartAnalyzeRunner = {
             ? ["analyze", "--format=machine", absPath]
             : ["analyze", "--machine", absPath];
         const result = await safeSpawnAsync(cmd, args, { cwd, timeout: 30000 });
-        if (result.error && !result.stdout && !result.stderr) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
         // dart analyze writes diagnostics to stderr in machine format
         const raw = (result.stderr || "") + (result.stdout || "");
-        const diagnostics = parseDartMachineOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            if (result.status && result.status !== 0) {
-                return {
-                    status: "failed",
-                    diagnostics: [
-                        {
-                            id: "dart-analyze-nonzero-no-diagnostics",
-                            message: firstOutputLine(result) ||
-                                "dart analyze exited non-zero without machine diagnostics",
-                            filePath: ctx.filePath,
-                            severity: "warning",
-                            semantic: "warning",
-                            tool: "dart",
-                            rule: "dart-analyze",
-                            fixable: false,
-                        },
-                    ],
-                    semantic: "warning",
-                };
-            }
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+        const parsed = parseToolRun("dart-analyze", {
+            result,
+            output: raw,
+            // EXIT TABLE (Dart 3.5 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseDartMachineOutput(out, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "dart-analyze",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+        });
     },
 };
 export default dartAnalyzeRunner;

package/node_modules/pi-lens/dist/clients/dispatch/runners/detekt.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { pathsEqual } from "../../path-utils.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
@@ -91,13 +92,14 @@ export function findDetektConfig(cwd) {
     return undefined;
 }
 // detekt text output: /path/file.kt:10:5: error: Message [RuleId]
-function parseDetektOutput(raw, filePath) {
+function parseDetektOutput(raw, filePath, cwd) {
     const diagnostics = [];
     const pattern = /^(.+?):(\d+):(\d+): (error|warning): (.+?)(?:\s+\[([^\]]+)\])?$/gm;
-    const absTarget = path.resolve(filePath);
+    const absTarget = path.resolve(cwd, filePath);
     for (const match of raw.matchAll(pattern)) {
         const [, file, lineStr, colStr, level, message, rule] = match;
-        if (path.resolve(file.trim()) !== absTarget)
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, file.trim()), absTarget))
             continue;
         const severity = level === "error" ? "error" : "warning";
         const lineNum = Number.parseInt(lineStr, 10);
@@ -150,7 +152,12 @@ const detektRunner = {
         // read the same concatenated string. A nonzero exit that yields zero
         // findings out of real output is a parser break, not clean Kotlin.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const run = parseToolRun("detekt", { result, output: raw }, (out) => parseDetektOutput(out, ctx.filePath));
+        const run = parseToolRun("detekt", {
+            result,
+            output: raw,
+            // EXIT TABLE (detekt 1.23 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseDetektOutput(out, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

package/node_modules/pi-lens/dist/clients/dispatch/runners/dotnet-build.js

@@ -1,9 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { pathsEqual } from "../../path-utils.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const dotnet = createAvailabilityChecker("dotnet", ".exe");
 function findProjectTarget(cwd) {
     const entries = fs.readdirSync(cwd);
@@ -83,16 +85,16 @@ function parseDotnetDiagnosticLine(line) {
     }
     return { reportedFile, lineStr, colStr, severityLabel, rule, message };
 }
-function parseDotnetBuildOutput(raw, filePath) {
+function parseDotnetBuildOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split(/\r?\n/)) {
         const parsed = parseDotnetDiagnosticLine(line);
         if (!parsed)
             continue;
         const { reportedFile, lineStr, colStr, severityLabel, rule, message } = parsed;
-        const resolvedReported = path.resolve(reportedFile);
-        const resolvedTarget = path.resolve(filePath);
-        if (resolvedReported !== resolvedTarget)
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, reportedFile), absTarget))
             continue;
         const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
         const lineNum = Number.parseInt(lineStr, 10) || 1;
@@ -136,24 +138,27 @@ const dotnetBuildRunner = {
             timeout: 60000,
         });
         const raw = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-        if (result.status === 0 && !raw) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseDotnetBuildOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return {
-                status: result.status === 0 ? "succeeded" : "failed",
-                diagnostics: [],
-                semantic: "warning",
-                rawOutput: raw,
-            };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+        const parsed = parseToolRun("dotnet-build", {
+            result,
+            output: raw,
+            // EXIT TABLE (.NET SDK 8 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (output) => parseDotnetBuildOutput(output, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "dotnet-build",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: hasErrors ? "failed" : "succeeded",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default dotnetBuildRunner;

package/node_modules/pi-lens/dist/clients/dispatch/runners/elixir-check.js

@@ -1,10 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "../../file-utils.js";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 // Per-cwd cached `--version` probes (#120). Before this, each dispatch
 // invocation fired a fresh `safeSpawnAsync` per command — once per Elixir
 // file save.
@@ -34,15 +36,15 @@ function parseElixirOutput(raw, filePath, cwd = process.cwd()) {
     const lines = raw.split(/\r?\n/);
     // elixirc reports paths RELATIVE to its cwd (e.g. `bad.ex`, not the absolute
     // path we passed), so resolve the reported path against the runner cwd — not
-    // process.cwd(). Elixir 1.16+ also normalizes to a lowercase drive letter and
-    // forward slashes (`c:/...`), which never string-equals `C:\...` on Windows,
-    // so compare case-insensitively there.
-    const matchesTarget = (sourcePath) => {
-        const resolved = path.resolve(cwd, sourcePath.trim());
-        return process.platform === "win32"
-            ? resolved.toLowerCase() === resolvedTarget.toLowerCase()
-            : resolved === resolvedTarget;
-    };
+    // process.cwd(). Two resolved spellings of ONE file still differ in ways
+    // only the filesystem can settle — Elixir 1.16+ normalizes to a lowercase
+    // drive letter and forward slashes (`c:/...`), which never string-equals
+    // `C:\...` on Windows — so ask `pathsEqual`, the repo's on-disk identity
+    // seam, instead of hand-rolling a win32 case fold here. It folds case
+    // exactly where the filesystem does and nowhere else, which a
+    // `process.platform` test cannot express; `terragrunt.ts:90` asks the same
+    // question the same way (#1193).
+    const matchesTarget = (sourcePath) => pathsEqual(path.resolve(cwd, sourcePath.trim()), resolvedTarget);
     for (let index = 0; index < lines.length; index++) {
         const line = lines[index];
         // Defense-in-depth: cap line length before regex matching. The input is
@@ -130,12 +132,6 @@ function parseElixirOutput(raw, filePath, cwd = process.cwd()) {
     }
     return diagnostics;
 }
-function firstOutputLine(result) {
-    return `${result.stderr || ""}\n${result.stdout || ""}`
-        .trim()
-        .split(/\r?\n/, 1)[0]
-        .slice(0, 200);
-}
 const elixirCheckRunner = {
     id: "elixir-check",
     appliesTo: ["elixir"],
@@ -163,47 +159,36 @@ const elixirCheckRunner = {
             cwd,
             timeout: 30000,
         });
-        if (result.error && !result.stdout && !result.stderr) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
         const raw = `${result.stderr || ""}\n${result.stdout || ""}`;
         const hasProjectContext = command === "mix";
-        const diagnostics = parseElixirOutput(raw, ctx.filePath, cwd).map((d) => hasProjectContext
+        const parsed = parseToolRun("elixir-check", {
+            result,
+            output: raw,
+            // EXIT TABLE (Elixir 1.16 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseElixirOutput(out, ctx.filePath, cwd).map((d) => hasProjectContext
             ? d
             : {
                 ...d,
                 // A direct elixirc invocation cannot resolve Mix dependencies.
                 // Standalone findings inform the agent, but cannot block it.
                 semantic: "warning",
-            });
-        if (diagnostics.length === 0) {
-            if (result.status && result.status !== 0) {
+            }));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "elixir-check",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+            classify: (diagnostics) => {
+                const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
                 return {
-                    status: "failed",
-                    diagnostics: [
-                        {
-                            id: "elixir-check-nonzero-no-diagnostics",
-                            message: firstOutputLine(result) ||
-                                `${command} exited non-zero without structured diagnostics`,
-                            filePath: ctx.filePath,
-                            severity: "error",
-                            semantic: hasProjectContext ? "blocking" : "warning",
-                            tool: "elixir-check",
-                            rule: command,
-                            fixable: false,
-                        },
-                    ],
-                    semantic: hasProjectContext ? "blocking" : "warning",
+                    status: hasBlocking ? "failed" : "succeeded",
+                    semantic: hasBlocking ? "blocking" : "warning",
                 };
-            }
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+            },
+        });
     },
 };
 export default elixirCheckRunner;

package/node_modules/pi-lens/dist/clients/dispatch/runners/eslint.js

@@ -6,11 +6,14 @@
  *
  * Gate: skips when no ESLint config is detected (project uses Biome/OxLint instead).
  */
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { getAutofixCapability, hasEslintConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createCwdCachedProbe, resolveToolCommand, } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const ESLINT_PROBE_BUDGET_MS = 5000;
 // Per-cwd cached eslint `--version` verification (#120). Before this, every
 // dispatch invocation ran a fresh `safeSpawnAsync(cmd, ["--version"])` after
@@ -40,12 +43,18 @@ function getEslintProbe(cmd) {
     eslintAvailabilityByCmd.set(cmd, created);
     return created;
 }
-function parseEslintJson(raw, filePath) {
+function parseEslintJson(raw, filePath, cwd) {
     try {
         const results = JSON.parse(raw);
         const autofix = getAutofixCapability("eslint");
         const diagnostics = [];
+        const absTarget = path.resolve(cwd, filePath);
         for (const fileResult of results) {
+            // #3295: flat config `files`/`ignores` and a directory argv both put a
+            // SECOND result in this array; each names its own `filePath`.
+            if (fileResult.filePath &&
+                !pathsEqual(path.resolve(cwd, fileResult.filePath), absTarget))
+                continue;
             for (const msg of fileResult.messages) {
                 const severity = msg.severity === 2 ? "error" : "warning";
                 diagnostics.push({
@@ -92,11 +101,11 @@ const eslintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-error-on-unmatched-pattern", ctx.filePath], { timeout: 30000, cwd });
-        // ESLint exits 2 on fatal/config errors — nothing was linted, so this
-        // is an unavailable run, not a clean or failed one.
-        if (result.status === 2) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
+        // Exit table: 0 is clean-or-findings, and 1/2 are ran outcomes whose
+        // JSON parser decides whether findings or a parse/config error reached the
+        // user. In particular, status 2 carries file-local fatal parse messages
+        // as JSON and must not be discarded before parsing.
+        //
         // ESLint exits 0 whenever nothing reached ERROR severity — that
         // includes a run that found only warnings (#1954), which also prints a
         // full JSON report. So parse stdout unconditionally and branch on the
@@ -109,46 +118,20 @@ const eslintRunner = {
         if (raw.length === 0 && result.status !== 0) {
             raw = result.stderr || "";
         }
-        const parsed = parseEslintJson(raw, ctx.filePath);
-        if (parsed.parseError && raw.trim().length > 0) {
-            const preview = raw.replace(/\s+/g, " ").slice(0, 160);
-            return {
-                status: "failed",
-                diagnostics: [
-                    {
-                        id: "eslint:parse-error:1",
-                        message: "ESLint JSON parse failed: " +
-                            parsed.parseError +
-                            (preview ? " (output preview: " + preview + ")" : ""),
-                        filePath: ctx.filePath,
-                        line: 1,
-                        column: 1,
-                        severity: "warning",
-                        semantic: "warning",
-                        tool: "eslint",
-                    },
-                ],
-                semantic: "warning",
-            };
-        }
-        const diagnostics = parsed.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
-        // A warning-only result on exit 0 is ESLint's normal outcome, not a
-        // failure: exit 0 means nothing hit ERROR severity. Keying status off
-        // blocking severity plus exit code (the sibling convention from oxlint,
-        // biome-check, golangci-lint, rubocop) keeps plan.ts's fallback group
-        // ["eslint", "oxlint", "biome-check-json"] stopping at eslint instead
-        // of re-running oxlint and biome-check-json on every warning-only save.
-        // The findings reach delivery regardless of status — dispatcher.ts
-        // buckets by each diagnostic's own `semantic`.
-        return {
-            status: !hasErrors && result.status === 0 ? "succeeded" : "failed",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+        const parsed = parseToolRun("eslint", {
+            result,
+            output: raw,
+            // EXIT TABLE (ESLint 9.10 docs https://eslint.org/docs/latest/use/command-line-interface): 0 clean; 1 findings; 2 fatal findings/error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (rawOutput) => parseEslintJson(rawOutput, ctx.filePath, cwd).diagnostics);
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "eslint",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+        });
     },
 };
 export default eslintRunner;