@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-EPAMVGI3.js

@@ -0,0 +1,1562 @@
+// src/utils/shell-backslash.ts
+function readShellBackslash(text, index, inDouble) {
+  const next = text[index + 1];
+  if (next === void 0) return { kind: "dangling", value: "\\", consumed: 1 };
+  if (next === "\n") return { kind: "continuation", value: "\n", consumed: 2 };
+  if (inDouble && !["$", "`", '"', "\\"].includes(next)) {
+    return { kind: "character", value: "\\", consumed: 1 };
+  }
+  return { kind: "character", value: next, consumed: 2 };
+}
+
+// src/core/project/verification-scope.ts
+function isMissingToolLaunch(exitCode, errorCode) {
+  return errorCode === "ENOENT" || exitCode === 127 || exitCode === 9009;
+}
+
+// src/core/project/launcher-not-found.ts
+function missingExecutableMessage(executable) {
+  return `Verification tool unavailable: executable '${executable}' was not found.`;
+}
+function launcherLinesCount(exitCode) {
+  return exitCode === void 0 || isMissingToolLaunch(exitCode);
+}
+function findLauncherMissingExecutable(output) {
+  const match = /(?:^|\n)\s*(?:(?:ba)?sh|zsh|dash|fish):\s*(?:\d+:\s*)?([a-z0-9_.-]+):\s*(?:command )?not found\b/i.exec(
+    output
+  ) ?? /(?:^|\n)\s*(?:sh:\s*(?:\d+:\s*)?)?([a-z0-9_.-]+):\s*command not found\b/i.exec(output) ?? /\bspawn\s+(?:[^\s/\\]+[/\\])*([a-z0-9_.-]+)(?:\s+[^\n]*?)?\s+enoent\b/i.exec(output);
+  return match?.[1];
+}
+function outputNamesMissingSubcommand(output, subcommand) {
+  const named = /(?:^|\n)\s*(?:error:\s*)?no such (?:sub)?command:?\s*[`'"]?([^\s`'"]+)/g;
+  return [...output.matchAll(named)].some((m) => m[1] === subcommand);
+}
+function outputNamesToolNotInstalledForToolchain(output, tool) {
+  const escaped = tool.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(
+    `(?:^|\\n)\\s*error:\\s*['"]${escaped}['"] is not installed for the toolchain\\b`
+  ).test(output);
+}
+function outputNamesInvokedNotFound(output, executable) {
+  const escaped = executable.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const invokedNotFound = new RegExp(
+    `(?:^|[\\s:])${escaped}:\\s*command not found[ \\t\\r]*$|(?:^|:)[ \\t]*command not found:\\s*${escaped}[ \\t\\r]*$`,
+    "m"
+  );
+  return invokedNotFound.test(output) || output.includes(`${executable}: not found`) || output.includes(`not found: ${executable}`);
+}
+var WRAPPER_INNER_EXIT_LINE = /^[^\n]*(?:\*\*\* (?:\[[^\]\n]*\] )?error(?: code)? |\bfailed on line \d+ with exit code |\bnon-zero exit (?:value|code|status) )(\d+)[ \t\r]*$/gim;
+var MAKE_LEVEL_PREFIX = /^\s*g?make(?:\[(\d+)\])?:/i;
+var MAKE_LAUNCH_FAILURE = /(?:^|\n)\s*g?make(?:\[\d+\])?:\s+([a-z0-9_.-]+):\s+no such file or directory\s*(?:\n|$)/i;
+function wrapperReportsInnerMissingLaunch(output) {
+  const lines = [...output.matchAll(WRAPPER_INNER_EXIT_LINE)].map((match) => {
+    const prefix = MAKE_LEVEL_PREFIX.exec(match[0]);
+    return { code: match[1], level: prefix ? Number(prefix[1] ?? 0) : void 0 };
+  });
+  const unexplainedChildren = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.level === void 0 || line.level === 0) continue;
+    unexplainedChildren.set(line.level, (unexplainedChildren.get(line.level) ?? 0) + 1);
+  }
+  const independent = lines.filter((line) => {
+    if (line.code !== "2" || line.level === void 0) return true;
+    const children = unexplainedChildren.get(line.level + 1) ?? 0;
+    if (children === 0) return true;
+    unexplainedChildren.set(line.level + 1, children - 1);
+    return false;
+  });
+  return independent.some((line) => line.code === "127") && independent.every((line) => line.code === "127");
+}
+function nestedMissingMessage(output, exitCode, wrapperExecutable, processExitCode) {
+  const wrapperReportedMiss = (processExitCode ?? exitCode) !== 0 && wrapperReportsInnerMissingLaunch(output);
+  const named = wrapperReportedMiss || launcherLinesCount(exitCode) ? findLauncherMissingExecutable(output) ?? (wrapperReportedMiss ? MAKE_LAUNCH_FAILURE.exec(output)?.[1] : void 0) : void 0;
+  if (named) return missingExecutableMessage(named);
+  return wrapperReportedMiss ? `Verification tool unavailable: a command run by '${wrapperExecutable}' was not found (inner exit 127).` : void 0;
+}
+
+// src/core/project/verification-command-argv.ts
+function parseVerificationCommandArgv(command) {
+  if (!command.trim()) return { error: "Verification command is empty." };
+  if (command.includes("`") || command.includes("$(")) {
+    return { error: "Verification command contains shell control syntax." };
+  }
+  const args = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let tokenStarted = false;
+  let i = 0;
+  const danglingEscape = { error: "Verification command has a dangling escape." };
+  const unterminatedQuote = { error: "Verification command has an unterminated quote." };
+  while (i < command.length) {
+    const ch = command[i];
+    if (inSingle) {
+      if (ch === "'") {
+        inSingle = false;
+      } else {
+        current += ch;
+      }
+      i += 1;
+      continue;
+    }
+    if (inDouble) {
+      if (ch === "\\") {
+        const decoded = readShellBackslash(command, i, true);
+        if (decoded.kind === "dangling") return danglingEscape;
+        if (decoded.kind !== "continuation") current += decoded.value;
+        i += decoded.consumed;
+        continue;
+      }
+      if (ch === '"') {
+        inDouble = false;
+        i += 1;
+        continue;
+      }
+      current += ch;
+      i += 1;
+      continue;
+    }
+    if ("|;<>".includes(ch) || ch === "&" && command[i + 1] === "&") {
+      return { error: "Verification command contains shell control syntax." };
+    }
+    if (ch === "\\") {
+      const decoded = readShellBackslash(command, i, false);
+      if (decoded.kind === "dangling") return danglingEscape;
+      if (decoded.kind !== "continuation") {
+        current += decoded.value;
+        tokenStarted = true;
+      }
+      i += decoded.consumed;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      tokenStarted = true;
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      tokenStarted = true;
+      i += 1;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (tokenStarted) {
+        args.push(current);
+        current = "";
+        tokenStarted = false;
+      }
+      i += 1;
+      continue;
+    }
+    current += ch;
+    tokenStarted = true;
+    i += 1;
+  }
+  if (inSingle || inDouble) return unterminatedQuote;
+  if (tokenStarted) args.push(current);
+  return args.length > 0 ? args : { error: "Verification command is empty." };
+}
+
+// src/core/project/python-coverage.ts
+var UNITTEST_MODULE = "unittest";
+function pythonUnittestDiscoveryArgs(startDirectory) {
+  return `discover -s ${startDirectory}`;
+}
+function hasPytestCovDeclared(text) {
+  return /\bpytest-cov\b/.test(text);
+}
+function hasCoveragePyDeclared(text, hasConfigFile, pytestCovDeclared) {
+  return hasConfigFile || pytestCovDeclared || /\[tool\.coverage/.test(text) || /\[coverage:/.test(text) || /(^|\n)\s*coverage(?:[<>=~! ]|\n|$)/.test(text);
+}
+function derivePythonCoverageCommands(input) {
+  const text = input.declaredDependencyText.toLowerCase();
+  const pytestCovDeclared = hasPytestCovDeclared(text);
+  const coveragePyDeclared = hasCoveragePyDeclared(
+    text,
+    input.hasCoveragePyConfigFile,
+    pytestCovDeclared
+  );
+  const build = input.buildPythonModuleCommand;
+  if (input.testShape === "pytest") {
+    if (pytestCovDeclared) return [build("pytest", "--cov")];
+    if (coveragePyDeclared)
+      return [build("coverage", "run -m pytest"), build("coverage", "report")];
+    return [];
+  }
+  if (input.testShape === "unittest" && input.unittestDiscoveryArgs !== null && coveragePyDeclared) {
+    return [build("coverage", `run -m ${UNITTEST_MODULE} ${input.unittestDiscoveryArgs}`)];
+  }
+  return [];
+}
+var COVERAGE_PY_NO_DATA = /no data to report|no data was collected/;
+var PYTHON_RUNNER_FAILURE = /^\s*failed\s*\(|\b[1-9]\d*\s+(?:failed|failures|error|errors)\b/im;
+var COVERAGE_NO_DATA = "Verification tool unavailable: coverage.py collected no data.";
+function classifyPythonModuleUnavailable(lowercasedCommand, lowercasedOutput) {
+  for (const match of lowercasedCommand.matchAll(/\s-m\s+([a-z0-9_.-]+)/g)) {
+    const moduleName = match[1];
+    if (moduleName !== void 0 && lowercasedOutput.includes(`no module named ${moduleName}`)) {
+      return `Verification tool unavailable: module '${moduleName}' is not installed.`;
+    }
+  }
+  if (!/\s-m\s+coverage\b/.test(lowercasedCommand)) return void 0;
+  if (!COVERAGE_PY_NO_DATA.test(lowercasedOutput)) return void 0;
+  if (/\s-m\s+coverage\s+run\b/.test(lowercasedCommand) && PYTHON_RUNNER_FAILURE.test(lowercasedOutput)) {
+    return void 0;
+  }
+  return COVERAGE_NO_DATA;
+}
+var UNITTEST_DISCOVERY_FLAGS = /* @__PURE__ */ new Set([
+  "-s",
+  "--start-directory",
+  "-t",
+  "--top-level-directory",
+  "-p",
+  "--pattern"
+]);
+function isSafeDiscoveryValue(value) {
+  if (value.startsWith("-") || value.startsWith("/") || value.startsWith("\\")) return false;
+  if (value.split(/[/\\]/).includes("..")) return false;
+  return /^[A-Za-z0-9_.*?[\]-]+(?:[/\\][A-Za-z0-9_.*?[\]-]+)*$/.test(value);
+}
+function isUnittestDiscoveryTail(tail) {
+  for (let index = 0; index < tail.length; index += 2) {
+    const flag = tail[index];
+    const value = tail[index + 1];
+    if (flag === void 0 || !UNITTEST_DISCOVERY_FLAGS.has(flag)) return false;
+    if (value === void 0 || !isSafeDiscoveryValue(value)) return false;
+  }
+  return true;
+}
+function isResolverPythonCoverageArgv(moduleArgs) {
+  if (moduleArgs.length === 1 && moduleArgs[0] === "report") return true;
+  if (moduleArgs[0] !== "run" || moduleArgs[1] !== "-m") return false;
+  const runner = moduleArgs[2];
+  const rest = moduleArgs.slice(3);
+  if (runner === "pytest") return rest.length === 0;
+  if (runner !== UNITTEST_MODULE) return false;
+  if (rest[0] !== "discover") return false;
+  return isUnittestDiscoveryTail(rest.slice(1));
+}
+
+// src/core/project/uv-run.ts
+var UV_RUN_PASSIVE_OPTIONS = /* @__PURE__ */ new Set([
+  "--frozen",
+  "--locked",
+  "--no-sync",
+  "--offline",
+  "-q",
+  "--quiet",
+  "--no-dev"
+]);
+var UV_RUN_TOOLS = /* @__PURE__ */ new Set([
+  "black",
+  "mypy",
+  "pytest",
+  "python",
+  "python3",
+  "ruff"
+]);
+function parseUvRunArgv(argv) {
+  if (argv[0] !== "uv" || argv[1] !== "run") return void 0;
+  let index = 2;
+  while (UV_RUN_PASSIVE_OPTIONS.has(argv[index] ?? "")) index += 1;
+  const tool = argv[index];
+  return tool !== void 0 && UV_RUN_TOOLS.has(tool) ? argv.slice(index) : void 0;
+}
+function unwrapUvRunCommand(command) {
+  const argv = command.trim().split(/\s+/);
+  return parseUvRunArgv(argv)?.join(" ") ?? command;
+}
+
+// src/core/project/verification-runner-dispatch.ts
+var PACKAGE_TEST_WRAPPER = /^(?:(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?|deno\s+task\s+)test\b/;
+function isPackageTestWrapperDescriptor(descriptor) {
+  return descriptor.language === "node" && descriptor.kind === "test" && PACKAGE_TEST_WRAPPER.test(descriptor.command.trim().replace(/\s+/g, " "));
+}
+function applicableRunnerLanguages(descriptor) {
+  if (descriptor.language === "unknown" || isPackageTestWrapperDescriptor(descriptor)) return "all";
+  return [descriptor.language];
+}
+function runnerRowApplies(descriptor, language) {
+  const languages = applicableRunnerLanguages(descriptor);
+  return languages === "all" || languages.includes(language);
+}
+
+// src/core/project/exit-zero-failure-detectors.ts
+function detectNodeExitZeroFailure(output) {
+  const vitestTestFiles = output.match(
+    /^\s*Test Files\s+.*?\b([1-9]\d*)\s+failed\b.*\(\d+\)\s*$/im
+  );
+  if (vitestTestFiles?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Vitest reported ${vitestTestFiles[1]} failed test file(s) despite exit code 0.`
+    };
+  }
+  const vitestTests = output.match(/^\s*Tests\s+.*?\b([1-9]\d*)\s+failed\b.*\(\d+\)\s*$/im);
+  if (vitestTests?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Vitest reported ${vitestTests[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  const jestSuites = output.match(
+    /^\s*Test Suites:\s+.*?\b([1-9]\d*)\s+failed\b.*,\s*\d+\s+total\s*$/im
+  );
+  if (jestSuites?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Jest reported ${jestSuites[1]} failed test suite(s) despite exit code 0.`
+    };
+  }
+  const jestTests = output.match(/^\s*Tests:\s+.*?\b([1-9]\d*)\s+failed\b.*,\s*\d+\s+total\s*$/im);
+  if (jestTests?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Jest reported ${jestTests[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  const mochaFailing = output.match(/^\s*([1-9]\d*)\s+failing\s*$/im);
+  if (mochaFailing?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Mocha reported ${mochaFailing[1]} failing test(s) despite exit code 0.`
+    };
+  }
+  return void 0;
+}
+function detectPythonExitZeroFailure(output) {
+  const pytestSummary = output.match(/^\s*=+\s+.*?\b([1-9]\d*)\s+failed\b.*?=+\s*$/im) ?? output.match(/^\s*([1-9]\d*)\s+failed\b.*\bin\s+\d+(?:\.\d+)?s\s*$/im);
+  if (pytestSummary?.[1]) {
+    return {
+      toolchain: "python",
+      message: `pytest reported ${pytestSummary[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  const mypySummary = output.match(
+    /^\s*Found\s+([1-9]\d*)\s+errors?\s+in\s+\d+\s+files?\s+\(checked\s+\d+\s+source\s+files?\)\s*$/im
+  );
+  if (mypySummary?.[1]) {
+    return {
+      toolchain: "python",
+      message: `mypy reported ${mypySummary[1]} error(s) despite exit code 0.`
+    };
+  }
+  return void 0;
+}
+function detectGoExitZeroFailure(output) {
+  if (
+    // `--- FAIL: TestX (0.00s)`, indented for a subtest.
+    /^[ \t]*---\s+FAIL:\s+\S+(?:\s+\(\d+(?:\.\d+)?s\))?\s*$/m.test(output) || // The bare `FAIL` line, and `FAIL<TAB>pkg<TAB>0.186s` / `FAIL<TAB>pkg [build failed]`.
+    /^FAIL\s*$/m.test(output) || /^FAIL\t\S+(?:\t\d+(?:\.\d+)?s| \[(?:build|setup) failed\])\s*$/m.test(output)
+  ) {
+    return {
+      toolchain: "go",
+      message: "go test reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectNativeExitZeroFailure(output) {
+  if (
+    // ctest: `Errors while running CTest` and `50% tests passed, 1 tests failed out of 2`.
+    /^\s*Errors while running CTest\s*$/m.test(output) || /^\s*\d+%\s+tests passed,\s+[1-9]\d*\s+tests?\s+failed\s+out\s+of\s+\d+\s*$/m.test(output) || // ninja's own stop line (every failed build ends with one, with or without -k) and its
+    // load-time errors. The preceding `FAILED: <edge>` line is not matched on its own: a
+    // line starting with that word is not specific to ninja.
+    /^ninja: build stopped: .+$/m.test(output) || /^ninja: error: .+$/m.test(output) || // meson test: the failures heading, a failed result row, and the Ok/Fail totals block
+    // (`Fail:              0` is the passing form).
+    /^Summary of Failures:\s*$/m.test(output) || /^\d+\/\d+\s+\S+\s+FAIL\s+\d+(?:\.\d+)?s\b.*$/m.test(output) || /^Ok:[ \t]+\d+[ \t]*\r?\n(?:Expected Fail:[ \t]+\d+[ \t]*\r?\n)?Fail:[ \t]+[1-9]\d*[ \t]*$/m.test(
+      output
+    )
+  ) {
+    return {
+      toolchain: "native",
+      message: "Native build/test tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectRustExitZeroFailure(output) {
+  const rustFailure = output.match(
+    /^\s*test result:\s+FAILED\.\s+\d+\s+passed;\s+([1-9]\d*)\s+failed;.*$/im
+  );
+  if (rustFailure?.[1]) {
+    return {
+      toolchain: "rust",
+      message: `cargo reported ${rustFailure[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  return void 0;
+}
+function detectJvmExitZeroFailure(output) {
+  if (
+    // Gradle `BUILD FAILED in 5s` (Ant prints it bare) and Maven `[ERROR] BUILD FAILURE`.
+    /^\s*BUILD FAILED(?: in .+)?\s*$/m.test(output) || /^(?:\[ERROR\]\s+)?BUILD FAILURE\s*$/m.test(output) || // Gradle's report line, with the `> ` prefix under FAILURE and without it when
+    // `ignoreFailures` lets the build exit 0 after failing tests.
+    /^(?:>\s+)?There were failing tests\. See the report at: .+$/m.test(output)
+  ) {
+    return {
+      toolchain: "jvm",
+      message: "JVM build tool reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectDotnetExitZeroFailure(output) {
+  if (/^\s*Failed!\s+-\s+Failed:\s*[1-9]\d*,\s*Passed:\s*\d+,\s*Skipped:\s*\d+,\s*Total:\s*\d+(?:,.*)?$/m.test(
+    output
+  ) || // MSBuild's own final status line, cased as it prints it.
+  /^\s*Build FAILED\.\s*$/m.test(output)) {
+    return {
+      toolchain: "dotnet",
+      message: ".NET tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectSwiftExitZeroFailure(output, descriptor) {
+  const swiftSpecificFailure = /^\s*\*\*\s+TEST FAILED\s+\*\*\s*$/m.test(output) || /^\s*Test Suite '.+' failed at .+$/m.test(output);
+  if (descriptor.language !== "swift" && descriptor.language !== "unknown" && !isPackageTestWrapperDescriptor(descriptor))
+    return void 0;
+  if (descriptor.language === "swift" && /^\s*(?:.+?:\d+:\d+:\s+)?error:\s/im.test(output) || swiftSpecificFailure) {
+    return {
+      toolchain: "swift",
+      message: "Swift tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectDartExitZeroFailure(output, descriptor) {
+  if (descriptor.language !== "dart" && descriptor.language !== "unknown" && !isPackageTestWrapperDescriptor(descriptor))
+    return void 0;
+  if (/^\s*\d{2}:\d{2}(?::\d{2})?(?:\s+[+~-]\d+)+:\s*Some tests failed\.\s*$/m.test(output) || /^\s*\d{2}:\d{2}(?::\d{2})?(?:\s+[+~]\d+)+\s+-[1-9]\d*:\s+\S.*$/m.test(output)) {
+    return {
+      toolchain: "dart",
+      message: "Dart/Flutter tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectRubyExitZeroFailure(output) {
+  if (
+    // Minitest: `2 runs, 2 assertions, 1 failures, 0 errors, 0 skips`.
+    /^\d+ runs, \d+ assertions, [1-9]\d* failures, \d+ errors, \d+ skips\s*$/m.test(output) || /^\d+ runs, \d+ assertions, \d+ failures, [1-9]\d* errors, \d+ skips\s*$/m.test(output) || // RSpec: `2 examples, 1 failure` and `0 examples, 0 failures, 1 error occurred outside of examples`.
+    /^\d+ examples?, [1-9]\d* failures?(?:, \d+ pending)?(?:, \d+ errors? occurred outside of examples)?\s*$/m.test(
+      output
+    ) || /^\d+ examples?, \d+ failures?(?:, \d+ pending)?, [1-9]\d* errors? occurred outside of examples\s*$/m.test(
+      output
+    )
+  ) {
+    return {
+      toolchain: "ruby",
+      message: "Ruby test tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectPhpExitZeroFailure(output) {
+  if (
+    // PHPUnit: the `FAILURES!` heading and `Tests: 2, Assertions: 2, Failures: 1.` totals
+    // (`Errors: n` leads when present; `Skipped`, `Risky` and the rest may follow).
+    /^FAILURES!\s*$/m.test(output) || /^Tests:\s*\d+,\s*Assertions:\s*\d+(?:,\s*[A-Za-z ]+:\s*\d+)*?,\s*(?:Errors|Failures):\s*[1-9]\d*(?:,\s*[A-Za-z ]+:\s*\d+)*\.\s*$/m.test(
+      output
+    )
+  ) {
+    return {
+      toolchain: "php",
+      message: "PHP test tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectShellExitZeroFailure(output) {
+  if (
+    // ShellCheck prints no summary line: its error findings are the status lines, in the
+    // default tty format (`^-- SC1049 (error): ...`, `^----^ SC2034 (error): ...`) and
+    // the gcc format (`error.sh:2:1: error: ... [SC1049]`).
+    /^\s*\^[-^]*\s+SC\d{4}\s+\(error\):\s+\S.*$/m.test(output) || /^\S[^\n]*?:\d+:\d+:\s+error:\s+.+\s\[SC\d{4}\]\s*$/m.test(output)
+  ) {
+    return {
+      toolchain: "shell",
+      message: "ShellCheck reported errors despite exit code 0."
+    };
+  }
+  const pester = output.match(
+    /^Tests Passed:\s*\d+,\s*Failed:\s*([1-9]\d*),\s*Skipped:\s*\d+,\s*Inconclusive:\s*\d+,\s*NotRun:\s*\d+\s*$/m
+  );
+  if (pester?.[1]) {
+    return {
+      toolchain: "shell",
+      message: `Pester reported ${pester[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  return void 0;
+}
+function detectRExitZeroFailure(output, descriptor) {
+  if (descriptor.language !== "r" && descriptor.language !== "unknown" && !isPackageTestWrapperDescriptor(descriptor))
+    return void 0;
+  if (/^\s*\*\s+checking\b.+\.\.\.\s+ERROR\s*$/m.test(output) || /^\s*Status:\s+[1-9]\d*\s+ERRORs?(?:,.*)?$/m.test(output) || // testthat's bracketed summary, e.g. `[ FAIL 1 | WARN 0 | SKIP 0 | PASS 4 ]`.
+  descriptor.language === "r" && /^\s*\[\s*FAIL\s+[1-9]\d*\s*\|\s*WARN\s+\d+\s*\|\s*SKIP\s+\d+\s*\|\s*PASS\s+\d+\s*\]\s*$/m.test(
+    output
+  )) {
+    return {
+      toolchain: "r",
+      message: "R tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+var ANSI_COLOR = new RegExp(String.raw`\x1B\[[0-9;]*m`, "g");
+function detectSqlExitZeroFailure(output) {
+  const plain = output.replace(ANSI_COLOR, "");
+  if (
+    // dbt: `Completed with 1 error, 0 partial successes, and 0 warnings:` and the
+    // `Done. PASS=3 WARN=0 ERROR=1 SKIP=0 ...` totals, each after a `00:48:55  ` timestamp.
+    /^(?:\d{2}:\d{2}:\d{2}\s+)?Completed with\s+[1-9]\d*\s+errors?\b.*\bwarnings?:\s*$/m.test(
+      plain
+    ) || /^(?:\d{2}:\d{2}:\d{2}\s+)?Done\.\s+PASS=\d+\s+WARN=\d+\s+ERROR=[1-9]\d*(?:\s+[A-Z-]+=\d+)*\s*$/m.test(
+      plain
+    ) || // sqlfluff lists only failing files, as `== [path/to/file.sql] FAIL`; `All Finished!` is
+    // printed whatever the result.
+    /^== \[.+\] FAIL\s*$/m.test(plain)
+  ) {
+    return {
+      toolchain: "sql",
+      message: "SQL/dbt tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+var EXIT_ZERO_FAILURE_DETECTORS = {
+  node: detectNodeExitZeroFailure,
+  python: detectPythonExitZeroFailure,
+  native: detectNativeExitZeroFailure,
+  go: detectGoExitZeroFailure,
+  rust: detectRustExitZeroFailure,
+  jvm: detectJvmExitZeroFailure,
+  dotnet: detectDotnetExitZeroFailure,
+  swift: detectSwiftExitZeroFailure,
+  dart: detectDartExitZeroFailure,
+  ruby: detectRubyExitZeroFailure,
+  php: detectPhpExitZeroFailure,
+  shell: detectShellExitZeroFailure,
+  r: detectRExitZeroFailure,
+  sql: detectSqlExitZeroFailure
+};
+function orderedExitZeroFailureDetectors(descriptor) {
+  const languages = applicableRunnerLanguages(descriptor);
+  return languages === "all" ? Object.values(EXIT_ZERO_FAILURE_DETECTORS) : languages.map((language) => EXIT_ZERO_FAILURE_DETECTORS[language]);
+}
+
+// src/core/project/missing-dependency-signatures.ts
+var RUBY_ERROR_LOCATION = String.raw`\S+:\d+:in [^\n]*?: `;
+var BUNDLER_GEM_NOT_FOUND_LINE = new RegExp(
+  `(?:^|\\n)(?:bundler::gemnotfound\\b|${RUBY_ERROR_LOCATION}[^\\n]*\\(bundler::gemnotfound\\)[ \\t\\r]*(?=\\n|$))`
+);
+var BUNDLER_LOCKED_GEM_MISSING = new RegExp(
+  `(?:^|\\n)(?:${RUBY_ERROR_LOCATION})?could not find (?:[a-z0-9_.-]+-\\d[^\\s,]*, )*[a-z0-9_.-]+-\\d[^\\s,]* in (?:locally installed gems|any of the sources)`
+);
+var BUNDLER_COULD_NOT_FIND_GEM = /(?:^|\n)could not find gem '[^'\n]+'/;
+var BUNDLE_INSTALL_HINT = /(?:^|\n)run `bundle install`/;
+var CARGO_OFFLINE_DEPENDENCY_MISSING = new RegExp(
+  "(?:^|\\n)error: no matching package named `[^`\\n]+` found\\r?\\n(?:location searched: [^\\n]*\\r?\\n)?required by package [^\\n]*\\r?\\nas a reminder, you're using offline mode \\(--(?:offline|frozen)\\)"
+);
+var CARGO_RAN_CODE = /(?:^|\n)[ \t]*(?:compiling |running |test result:|error: test failed|error: could not compile)|\n[ \t]*test \S+ \.\.\. (?:ok|failed)/;
+var MAVEN_RAN_CODE = /t e s t s|tests run:|<<< (?:failure|error)!|compiling \d+ source file|compilation error|build success/;
+var MAVEN_OFFLINE_ARTIFACT_MISSING = /(?:^|\n)\[error\][ \t]+cannot access [^\n]*\([^)\n]+\) in offline mode and the artifact [^\n]+ has not been downloaded from it before\./;
+var GO_ALLOWED_LINE = [
+  /^go: (?:downloading|finding) \S.*$/,
+  /^# \S+$/,
+  /^[^\s:]+\.go:\d+:\d+: module lookup disabled by goproxy=off$/,
+  /^fail$/,
+  /^ok\s*\t.*$/,
+  /^\?\s*\t.*\[no test files\]$/,
+  // Execa's shortMessage line, appended to the process output by the caller.
+  /^command failed with exit code \d+(?::.*)?$/
+];
+var GO_LOOKUP_DISABLED_LINE = /^[^\s:]+\.go:\d+:\d+: module lookup disabled by goproxy=off$/;
+var GO_SETUP_FAILED_LINE = /^fail\t\S+ \[setup failed\]$/;
+function isGoOfflineModuleMiss(output) {
+  const lines = output.split("\n").map((line) => line.replace(/\r$/, "").trimEnd()).filter((line) => line !== "");
+  let lookups = 0;
+  let setupFailures = 0;
+  for (const line of lines) {
+    if (GO_LOOKUP_DISABLED_LINE.test(line)) lookups += 1;
+    else if (GO_SETUP_FAILED_LINE.test(line)) setupFailures += 1;
+    else if (!GO_ALLOWED_LINE.some((allowed) => allowed.test(line))) return false;
+  }
+  return lookups > 0 && setupFailures > 0;
+}
+var MISSING_DEPENDENCY_SIGNATURES = [
+  {
+    heads: /* @__PURE__ */ new Set(["bundle", "rake", "rspec"]),
+    // `bundler: failed to load command:` is always followed by the GemNotFound line.
+    matches: (output) => BUNDLER_GEM_NOT_FOUND_LINE.test(output) || BUNDLER_LOCKED_GEM_MISSING.test(output) || BUNDLER_COULD_NOT_FIND_GEM.test(output) && BUNDLE_INSTALL_HINT.test(output),
+    message: "Verification tool unavailable: Ruby gems are not installed (run bundle install)."
+  },
+  {
+    heads: /* @__PURE__ */ new Set(["cargo"]),
+    matches: (output) => CARGO_OFFLINE_DEPENDENCY_MISSING.test(output) && !CARGO_RAN_CODE.test(output),
+    message: "Verification tool unavailable: Cargo dependencies are not available offline (fetch them first)."
+  },
+  {
+    heads: /* @__PURE__ */ new Set(["mvn", "mvnw"]),
+    matches: (output) => MAVEN_OFFLINE_ARTIFACT_MISSING.test(output) && !MAVEN_RAN_CODE.test(output),
+    message: "Verification tool unavailable: Maven plugins or dependencies are not in the local repository (offline)."
+  },
+  {
+    heads: /* @__PURE__ */ new Set(["go"]),
+    matches: isGoOfflineModuleMiss,
+    message: "Verification tool unavailable: Go modules are not in the module cache and module lookup is disabled (fetch them first)."
+  }
+];
+function detectMissingDependencySignature(executable, output, exitCode) {
+  if (exitCode === 0 || exitCode === 124) return void 0;
+  return MISSING_DEPENDENCY_SIGNATURES.find(
+    (signature) => signature.heads.has(executable) && signature.matches(output)
+  )?.message;
+}
+
+// src/core/project/node-style-tools.ts
+var LOCAL_JS_TOOL_PREFIX = String.raw`(?:(?:npx|pnpx|bunx)\s+(?:--no-install|--offline)\s+)?`;
+var BIOME_OR_ESLINT = new RegExp(`^${LOCAL_JS_TOOL_PREFIX}(?:biome|eslint)\\b`);
+var RUNNER_PASSIVE_FLAGS = /* @__PURE__ */ new Set(["--no-install", "--offline", "--yes", "-y", "--no", "--"]);
+var PRETTIER_TOOL = /^(?:prettier|(?:[^\s]*[/\\])?node_modules[/\\]\.bin[/\\]prettier)$/;
+function toolIndexAfterRunner(args) {
+  const head = args[0] ?? "";
+  let index;
+  if (head === "npx" || head === "pnpx" || head === "bunx") index = 1;
+  else if ((head === "npm" || head === "pnpm" || head === "yarn") && args[1] === "exec") index = 2;
+  else if (head === "bun" && args[1] === "x") index = 2;
+  else return 0;
+  while (index < args.length && (args[index] ?? "").startsWith("-")) {
+    if (!RUNNER_PASSIVE_FLAGS.has(args[index] ?? "")) return -1;
+    index += 1;
+  }
+  return index;
+}
+function prettierIndex(argv) {
+  const index = toolIndexAfterRunner(argv);
+  return index >= 0 && PRETTIER_TOOL.test(argv[index] ?? "") ? index : -1;
+}
+function isPrettierCheck(normalized) {
+  const argv = parseVerificationCommandArgv(normalized);
+  if (!Array.isArray(argv)) return false;
+  const index = prettierIndex(argv);
+  if (index < 0) return false;
+  let checks = false;
+  for (const arg of argv.slice(index + 1)) {
+    if (arg === "--check" || arg === "--list-different") checks = true;
+    else if (arg === "--write" || arg.startsWith("--write=")) return false;
+    else if (/^-[a-zA-Z]+$/.test(arg)) {
+      if (arg.includes("w")) return false;
+      if (arg.includes("c") || arg.includes("l")) checks = true;
+    }
+  }
+  return checks;
+}
+function classifyNodeStyleTool(normalized) {
+  if (BIOME_OR_ESLINT.test(normalized)) return "lint";
+  return isPrettierCheck(normalized) ? "format" : void 0;
+}
+function isPrettierInvocation(tokens) {
+  return prettierIndex(tokens) >= 0;
+}
+
+// src/core/project/verification-command-metadata.ts
+var FAST_SCRIPT_KEYS = /* @__PURE__ */ new Set(["typecheck", "type-check", "lint", "test:smoke"]);
+var BROAD_SCRIPT_KEYS = /* @__PURE__ */ new Set([
+  "test",
+  "test:unit",
+  "test:core",
+  "test:automation",
+  "test:coverage",
+  "build"
+]);
+function scriptWord(pattern) {
+  return new RegExp(`(?<![A-Za-z0-9])(?:${pattern})(?![A-Za-z0-9])`);
+}
+var LINT_WORD = scriptWord("lint");
+var TYPECHECK_WORD = scriptWord("type-?check|analy[sz]e|phpstan|psalm");
+var BUILD_WORD = scriptWord("build");
+var FAST_COST_WORD = scriptWord("smoke|unit|fast");
+function kindFromScriptName(script) {
+  if (LINT_WORD.test(script)) return "lint";
+  if (TYPECHECK_WORD.test(script)) return "typecheck";
+  if (BUILD_WORD.test(script)) return "build";
+  return "test";
+}
+function scriptCostClass(script) {
+  if (FAST_SCRIPT_KEYS.has(script)) return "fast";
+  if (BROAD_SCRIPT_KEYS.has(script)) return "broad";
+  return FAST_COST_WORD.test(script) ? "medium" : "broad";
+}
+function classifyScriptRunnerCommand(normalized) {
+  const node = /^(?:(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?|deno\s+task\s+|deno\s+(?=(?:test|lint)(?:\s|$)))((?:test|lint|typecheck|type-check|build)(?:[:._-][\w:.-]*)?)(?=\s|$)/.exec(
+    normalized
+  );
+  if (node?.[1]) {
+    return {
+      language: "node",
+      kind: kindFromScriptName(node[1]),
+      scope: "unknown",
+      costClass: scriptCostClass(node[1])
+    };
+  }
+  if (/^composer\s+(?:run|run-script|test|exec)\b/.test(normalized)) {
+    const tokens = normalized.split(" ").slice(2);
+    const script = /^composer\s+(?:run|run-script)\b/.test(normalized) ? tokens.find((token) => token !== "--" && !token.startsWith("-")) : void 0;
+    let kind;
+    if (/^composer\s+exec\b/.test(normalized)) {
+      const executable = (tokens.find((token) => token !== "--" && !token.startsWith("-")) ?? "").replace(/^.*[/\\]/, "");
+      kind = /^(?:phpstan|psalm)(?:\.phar)?$/.test(executable) ? "typecheck" : /^(?:phpcs|php-cs-fixer|pint|phpcbf)(?:\.phar)?$/.test(executable) ? "lint" : "test";
+    } else {
+      kind = script ? kindFromScriptName(script) : "test";
+    }
+    return {
+      language: "php",
+      kind,
+      scope: "full",
+      costClass: kind === "lint" || kind === "typecheck" ? "fast" : "broad"
+    };
+  }
+  return void 0;
+}
+function classifyNinjaCommand(normalized) {
+  if (!/^ninja\b/.test(normalized)) return void 0;
+  const targets = [];
+  const tokens = normalized.split(" ");
+  for (let index = 1; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "-t" || token === "--tool") return void 0;
+    if (["-C", "-f", "-j", "-k", "-l", "-d"].includes(token)) {
+      index += 1;
+      continue;
+    }
+    if (/^-(?:C|f|j|k|l|d).+/.test(token)) continue;
+    if (token === "-v") continue;
+    if (token.startsWith("-")) return void 0;
+    targets.push(token);
+  }
+  if (targets.length === 0) return "build";
+  if (targets.every((target) => /^(?:all|default|build)$/.test(target))) return "build";
+  if (targets.every((target) => /(?:^|:)(?:test|check|tests|checks)$/.test(target))) {
+    return "test";
+  }
+  return void 0;
+}
+function classifyMakeCommand(normalized) {
+  if (!/^make\b/.test(normalized)) return void 0;
+  const tokens = normalized.split(" ").slice(1);
+  const targets = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token.startsWith("-")) {
+      if (MAKE_VALUE_OPTIONS.has(token)) {
+        index += 1;
+      } else if (MAKE_OPTIONAL_NUMBER_OPTIONS.has(token) && /^\d+(?:\.\d+)?$/.test(tokens[index + 1] ?? "")) {
+        index += 1;
+      }
+      continue;
+    }
+    if (token.includes("=")) continue;
+    targets.push(token);
+  }
+  if (targets.some((target) => /^(?:test|tests|check|checks)$/.test(target))) return "test";
+  if (targets.some((target) => /^(?:build|all)$/.test(target))) return "build";
+  return void 0;
+}
+var MAKE_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "-C",
+  "--directory",
+  "-f",
+  "--file",
+  "--makefile",
+  "-I",
+  "--include-dir",
+  "-o",
+  "--old-file",
+  "--assume-old",
+  "-W",
+  "--what-if",
+  "--new-file",
+  "--assume-new"
+]);
+var MAKE_OPTIONAL_NUMBER_OPTIONS = /* @__PURE__ */ new Set(["-j", "--jobs", "-l", "--load-average"]);
+var CARGO_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--test",
+  "--bin",
+  "--example",
+  "--bench",
+  "-p",
+  "--package",
+  "--exclude",
+  "-F",
+  "--features",
+  "--target",
+  "--target-dir",
+  "--manifest-path",
+  "--profile",
+  "-j",
+  "--jobs",
+  "--color",
+  "--message-format",
+  "--config",
+  "-Z"
+]);
+var CARGO_SELECTOR_FLAGS = /* @__PURE__ */ new Set(["--test", "--bin", "--example", "-p", "--package"]);
+function cargoTestScope(args) {
+  let targeted = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? "";
+    if (token === "--") break;
+    if (token === "--workspace" || token === "--all") return "full";
+    if (!token.startsWith("-")) {
+      targeted = true;
+      continue;
+    }
+    const flag = token.split("=")[0] ?? token;
+    if (CARGO_SELECTOR_FLAGS.has(flag) && (token.includes("=") || args[index + 1])) {
+      targeted = true;
+    } else if (/^-p[^-]/.test(token)) {
+      targeted = true;
+    }
+    if (CARGO_VALUE_FLAGS.has(token)) index += 1;
+  }
+  return targeted ? "targeted" : "full";
+}
+function splitQuotedWords(command) {
+  const words = [];
+  let current = "";
+  let started = false;
+  let quote;
+  for (let index = 0; index < command.length; index += 1) {
+    const ch = command[index] ?? "";
+    if (quote) {
+      if (ch === quote) quote = void 0;
+      else if (ch === "\\" && quote === '"' && index + 1 < command.length) {
+        index += 1;
+        current += command[index];
+      } else current += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+      started = true;
+    } else if (ch === "\\" && index + 1 < command.length) {
+      index += 1;
+      current += command[index];
+      started = true;
+    } else if (/[|&;<>`]/.test(ch) || ch === "$" && command[index + 1] === "(") {
+      return void 0;
+    } else if (/\s/.test(ch)) {
+      if (started) words.push(current);
+      current = "";
+      started = false;
+    } else {
+      current += ch;
+      started = true;
+    }
+  }
+  if (started) words.push(current);
+  return words;
+}
+var GRADLE_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-p",
+  "--project-dir",
+  "-b",
+  "--build-file",
+  "-c",
+  "--settings-file",
+  "-g",
+  "--gradle-user-home",
+  "-I",
+  "--init-script",
+  "-x",
+  "--exclude-task",
+  "--include-build",
+  "--console",
+  "--warning-mode",
+  "--max-workers"
+]);
+var GRADLE_TESTISH_TASK = /^(?!compile)(?:check|build|verify|\w*[tT]est\w*|\w*Check)$/;
+function gradleTestScope(args) {
+  const tasks = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? "";
+    if (token === "--tests" || token.startsWith("--tests=")) {
+      const previous = tasks[tasks.length - 1];
+      if (previous) previous.filtered = true;
+      if (token === "--tests") index += 1;
+    } else if (token.startsWith("-")) {
+      if (GRADLE_VALUE_FLAGS.has(token)) index += 1;
+    } else {
+      tasks.push({ name: token, filtered: false });
+    }
+  }
+  const unfilteredTestTask = tasks.some(
+    (task) => !task.filtered && GRADLE_TESTISH_TASK.test(task.name.split(":").pop() ?? "")
+  );
+  return tasks.some((task) => task.filtered) && !unfilteredTestTask ? "targeted" : "full";
+}
+function testSelectorScope(normalized, parseMavenSelector) {
+  if (/^(?:\.\/)?mvnw?\b/.test(normalized)) {
+    const hasSelector = normalized.split(/\s+/).some((token) => parseMavenSelector?.(token));
+    return hasSelector ? "targeted" : "full";
+  }
+  const argv = splitQuotedWords(normalized);
+  if (!argv) return "full";
+  if (/^cargo (?:test|nextest run)\b/.test(normalized)) {
+    return cargoTestScope(argv.slice(argv[1] === "nextest" ? 3 : 2));
+  }
+  if (/^(?:\.\/)?gradlew?\b/.test(normalized)) return gradleTestScope(argv.slice(1));
+  if (/^ctest\b/.test(normalized)) {
+    return argv.some((token) => /^(?:-R.*|--tests-regex(?:=.*)?)$/.test(token)) ? "targeted" : "full";
+  }
+  return "full";
+}
+
+// src/core/project/zero-collected-detectors.ts
+function detectsBatsZeroCollected(output) {
+  if (/^[ \t]*(?:not ok|ok)[ \t]+\d+\b/m.test(output)) return false;
+  if (/^[ \t]*1\.\.[1-9]\d*[ \t\r]*(?:#.*)?$/m.test(output)) return false;
+  return /^[ \t]*1\.\.0[ \t\r]*(?:#.*)?$/m.test(output);
+}
+function detectsDbtZeroCollected(output) {
+  if (/\b(?:PASS|TOTAL)=[1-9]\d*/.test(output)) return false;
+  return /\bNothing to do\.[ \t]+Try checking your model configs\b/.test(output);
+}
+
+// src/core/project/verification-toolchains.ts
+var PYTHON_INTERPRETER_HEAD = /^(?:[\w./-]*[/\\])?(?:python3?|py)(?:\.exe)?(?=\s|$)/;
+function normalizeCommand(command) {
+  return command.trim().replace(/\s+/g, " ");
+}
+function unwrapEnvPythonPathPrefix(normalized) {
+  if (!normalized.startsWith("env ")) return normalized;
+  const parts = parseVerificationCommandArgv(normalized);
+  if (!Array.isArray(parts) || parts[0] !== "env") return normalized;
+  let index = 1;
+  for (; index < parts.length; index += 1) {
+    const token = parts[index] ?? "";
+    if (!token.includes("=")) break;
+    if (!token.startsWith("PYTHONPATH=")) return normalized;
+  }
+  return index > 1 && index < parts.length ? parts.slice(index).join(" ") : normalized;
+}
+function unwrapTrustedEnvPythonPathPrefix(command) {
+  return unwrapEnvPythonPathPrefix(normalizeCommand(command));
+}
+var JVM_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "-b",
+  "--build-file",
+  "-c",
+  "--settings-file",
+  "-f",
+  "--file",
+  "-gs",
+  "--global-settings",
+  "-I",
+  "--init-script",
+  "-p",
+  "--project-dir",
+  "-pl",
+  "--projects",
+  "-P",
+  "--activate-profiles",
+  "-s",
+  "--settings"
+]);
+var MAVEN_TEST_SELECTOR_MAX_LENGTH = 512;
+var MAVEN_TEST_SELECTOR_MAX_COUNT = 32;
+var MAVEN_TEST_CLASS_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+function parseMavenTestSelectorToken(token) {
+  if (!token.startsWith("-Dtest=")) return void 0;
+  if (token.length > MAVEN_TEST_SELECTOR_MAX_LENGTH) return void 0;
+  const selectors = token.slice("-Dtest=".length).split(",");
+  if (selectors.length === 0 || selectors.length > MAVEN_TEST_SELECTOR_MAX_COUNT || selectors.some((selector) => !MAVEN_TEST_CLASS_PATTERN.test(selector))) {
+    return void 0;
+  }
+  return selectors;
+}
+function optionTakesSeparateValue(token) {
+  if (JVM_VALUE_OPTIONS.has(token)) return true;
+  if (token.startsWith("--") && token.includes("=")) return false;
+  return false;
+}
+function isAttachedJvmOptionValue(token) {
+  return /^-(?:b|c|f|gs|I|p|pl|P|s).+/.test(token) || /^--(?:build-file|settings-file|file|global-settings|init-script|project-dir|projects|activate-profiles|settings)=/.test(
+    token
+  );
+}
+function extractJvmVerificationGoals(command) {
+  const normalized = normalizeCommand(command);
+  if (!/^(?:\.\/)?(?:gradlew|gradle|mvnw|mvn)\b/.test(normalized)) return [];
+  const tokens = normalized.split(/\s+/).slice(1);
+  const goals = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "--") {
+      goals.push(...tokens.slice(index + 1).filter(Boolean));
+      break;
+    }
+    if (optionTakesSeparateValue(token)) {
+      index += 1;
+      continue;
+    }
+    if (isAttachedJvmOptionValue(token)) continue;
+    if (token.startsWith("-")) continue;
+    goals.push(token);
+  }
+  return goals;
+}
+function describeVerificationCommand(command, hint) {
+  const descriptor = describeVerificationCommandText(command);
+  const bucketKind = hint?.bucket;
+  return bucketKind && bucketKind !== "unknown" && bucketKind !== descriptor.kind ? { ...descriptor, kind: bucketKind } : descriptor;
+}
+function describeVerificationCommandText(command) {
+  const normalized = normalizeCommand(command);
+  const pythonNormalized = unwrapUvRunCommand(unwrapTrustedEnvPythonPathPrefix(normalized));
+  if (new RegExp(`^${LOCAL_JS_TOOL_PREFIX}(?:vitest|jest)\\b`).test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /\s(?:run\s+)?(?:tests?|src|__tests__|[^ ]+\.(?:test|spec)\.)/.test(normalized) ? "targeted" : "full",
+      costClass: /\b(?:--runInBand|--bail|--changed|--findRelatedTests)\b/.test(normalized) ? "medium" : "broad"
+    };
+  }
+  if (/^node\s+scripts\/[^ ]*(?:test|spec|verify|check)[^ ]*\.m?[cj]s\b/.test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: "unknown",
+      costClass: "unknown"
+    };
+  }
+  if (/^node\s+scripts\/dynamic-node-options\.mjs\s+(?:\.\/node_modules\/\.bin\/)?(?:vitest|jest)\b/.test(
+    normalized
+  )) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /\s(?:run\s+)?(?:tests?|src|__tests__|[^ ]+\.(?:test|spec)\.)/.test(normalized) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (/^node\s+(?:--[^\s]+\s+)*--test(?=\s|$)/.test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /--test\s+\S/.test(normalized) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (new RegExp(`^${LOCAL_JS_TOOL_PREFIX}(?:mocha|ava)\\b`).test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /\s(?:tests?|src|__tests__|[^ ]+\.(?:test|spec)\.)/.test(normalized) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (new RegExp(`^${LOCAL_JS_TOOL_PREFIX}playwright\\s+test\\b`).test(normalized) || new RegExp(`^${LOCAL_JS_TOOL_PREFIX}cypress\\s+run\\b`).test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  const nodeStyleKind = classifyNodeStyleTool(normalized);
+  if (nodeStyleKind) {
+    return { command, language: "node", kind: nodeStyleKind, scope: "full", costClass: "fast" };
+  }
+  const scriptRunner = classifyScriptRunnerCommand(normalized);
+  if (scriptRunner) {
+    return { command, ...scriptRunner };
+  }
+  {
+    const npxRunnerMatch = new RegExp(`^${LOCAL_JS_TOOL_PREFIX}([^\\s]+)`).exec(normalized);
+    const firstToken = npxRunnerMatch?.[1] ?? "";
+    const viaLocalRunner = Boolean(
+      // npx/pnpx/bunx --no-install|--offline tsc ... (the prefix matched and the
+      // runner target basename is tsc).
+      /^(?:npx|pnpx|bunx)\s/.test(normalized) && firstToken.replace(/^.*[/\\]/, "").replace(/\.(?:cmd|exe|ps1)$/i, "") === "tsc"
+    );
+    const firstTokenBasename = firstToken.replace(/^.*[/\\]/, "").replace(/\.(?:cmd|exe|ps1)$/i, "");
+    const isLocalBinPath = /[/\\]node_modules[/\\]\.bin[/\\]tsc(?:\.(?:cmd|exe|ps1))?(?:\s|$)/i.test(firstToken);
+    const isBasenameTsc = firstTokenBasename === "tsc";
+    const hasTsCompilerFlag = /(?:^|\s)(?:--noEmit|-p|--project|-b|--build)(?:\s|=|$)/.test(
+      normalized
+    );
+    const hasTsconfigArg = /(?:^|\s|=)[^\s]*tsconfig[^\s]*\.json(?:\s|$)/i.test(normalized);
+    if (isBasenameTsc && (viaLocalRunner || isLocalBinPath || hasTsCompilerFlag || hasTsconfigArg)) {
+      return {
+        command,
+        language: "node",
+        kind: "typecheck",
+        scope: "full",
+        // Fast, matching the `typecheck` package-script policy autoloop enforces.
+        costClass: "fast"
+      };
+    }
+  }
+  const pythonModuleTest = /^pytest\b/.test(pythonNormalized) || PYTHON_INTERPRETER_HEAD.test(pythonNormalized) && /\s(?:-m\s+(?:pytest|unittest)|manage\.py\s+test)\b/.test(pythonNormalized);
+  if (pythonModuleTest) {
+    return {
+      command,
+      language: "python",
+      kind: "test",
+      // `manage.py test` is the runner's entry point, not a path the run is narrowed to.
+      scope: /\s(?:tests?|[^ ]+\.py)\b/.test(pythonNormalized.replace(/\smanage\.py\s+test\b/, "")) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (/^(?:ruff|black|mypy|pyright|flake8)\b/.test(pythonNormalized)) {
+    return {
+      command,
+      language: "python",
+      kind: pythonNormalized.startsWith("black ") ? "format" : /^(?:mypy|pyright)\b/.test(pythonNormalized) ? "typecheck" : "lint",
+      scope: "full",
+      costClass: "fast"
+    };
+  }
+  const ninjaKind = classifyNinjaCommand(normalized);
+  if (/^(?:cmake|ctest|meson)\b/.test(normalized) || ninjaKind) {
+    const kind = ninjaKind ? ninjaKind : /^(?:ctest|meson\s+test)\b/.test(normalized) ? "test" : /^(?:cmake\s+--build|meson\s+compile)\b/.test(normalized) ? "build" : "unknown";
+    return {
+      command,
+      language: "native",
+      kind,
+      scope: kind === "test" ? testSelectorScope(normalized) : "full",
+      costClass: kind === "test" || kind === "build" ? "broad" : "unknown"
+    };
+  }
+  if (/^gofmt\b/.test(normalized)) {
+    return { command, language: "go", kind: "format", scope: "full", costClass: "fast" };
+  }
+  if (/^golangci-lint\b/.test(normalized)) {
+    return {
+      command,
+      language: "go",
+      kind: "lint",
+      scope: "full",
+      costClass: "fast"
+    };
+  }
+  if (/^go\s+(?:test|vet|build)\b/.test(normalized)) {
+    const kind = normalized.startsWith("go vet") ? "lint" : normalized.startsWith("go build") ? "build" : "test";
+    return {
+      command,
+      language: "go",
+      kind,
+      scope: normalized.includes("./...") ? "full" : "targeted",
+      costClass: kind === "lint" ? "fast" : "broad"
+    };
+  }
+  if (/^cargo\s+(?:fmt|clippy|check|test|build|audit|nextest\s+run)\b/.test(normalized)) {
+    const kind = normalized.startsWith("cargo fmt") ? "format" : normalized.startsWith("cargo clippy") ? "lint" : normalized.startsWith("cargo check") ? "typecheck" : normalized.startsWith("cargo build") ? "build" : normalized.startsWith("cargo audit") ? "unknown" : "test";
+    return {
+      command,
+      language: "rust",
+      kind,
+      scope: kind === "test" ? testSelectorScope(normalized) : "full",
+      costClass: kind === "test" || kind === "build" ? "broad" : "fast"
+    };
+  }
+  if (/^(?:\.\/)?(?:gradlew|gradle|mvnw|mvn)\b/.test(normalized)) {
+    const goals = extractJvmVerificationGoals(normalized);
+    const hasTestSelector = testSelectorScope(normalized, parseMavenTestSelectorToken) === "targeted";
+    const hasTestGoal = goals.some((goal) => /(?:^|:)(?:test|tests)$/.test(goal));
+    const hasLintGoal = goals.some((goal) => /(?:^|:)(?:check|lint)$/.test(goal));
+    const styleOnly = goals.length > 0 && goals.every((goal) => /(?:^|:)(?:checkstyle|spotless)[\w:-]*$/i.test(goal));
+    const hasCompileGoal = goals.some(
+      (goal) => /(?:^|:)(?:compile|test-compile|classes|testClasses|compile[A-Z][\w-]*)$/.test(goal)
+    );
+    return {
+      command,
+      language: "jvm",
+      kind: styleOnly ? "lint" : hasTestGoal ? "test" : hasLintGoal ? "lint" : hasCompileGoal ? "typecheck" : "build",
+      scope: hasTestSelector || normalized.includes(" ./") || goals.some((goal) => /:[^ ]*test$/.test(goal)) ? "targeted" : "full",
+      costClass: styleOnly ? "fast" : hasCompileGoal ? "medium" : "broad"
+    };
+  }
+  if (/^dotnet\s+(?:format|build|test)\b/.test(normalized)) {
+    return {
+      command,
+      language: "dotnet",
+      kind: normalized.startsWith("dotnet format") ? "format" : normalized.startsWith("dotnet build") ? "build" : "test",
+      scope: "full",
+      costClass: normalized.startsWith("dotnet format") ? "fast" : "broad"
+    };
+  }
+  if (/^swift\s+(?:build|test)\b/.test(normalized)) {
+    return {
+      command,
+      language: "swift",
+      kind: normalized.startsWith("swift build") ? "build" : "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  if (/^(?:flutter|dart)\s+(?:analyze|test)\b/.test(normalized)) {
+    return {
+      command,
+      language: "dart",
+      kind: /\banalyze\b/.test(normalized) ? "lint" : "test",
+      scope: "full",
+      costClass: /\banalyze\b/.test(normalized) ? "medium" : "broad"
+    };
+  }
+  if (/^(?:bundle\s+exec\s+)?(?:rake|rspec|rubocop)\b/.test(normalized)) {
+    return {
+      command,
+      language: "ruby",
+      kind: /\brubocop\b/.test(normalized) ? "lint" : "test",
+      scope: "full",
+      costClass: /\brubocop\b/.test(normalized) ? "fast" : "broad"
+    };
+  }
+  if (/^(?:phpunit|phpstan|psalm)\b/.test(normalized)) {
+    return {
+      command,
+      language: "php",
+      kind: /^(?:phpstan|psalm)\b/.test(normalized) ? "typecheck" : "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  if (/^shellcheck\b/.test(normalized)) {
+    return {
+      command,
+      language: "shell",
+      kind: "lint",
+      scope: "full",
+      costClass: "fast"
+    };
+  }
+  if (/^R\s+CMD\s+check\b/.test(command.trim())) {
+    return {
+      command,
+      language: "r",
+      kind: "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  if (/^(?:dbt|sqlfluff)\b/.test(normalized)) {
+    return {
+      command,
+      language: "sql",
+      kind: normalized.startsWith("sqlfluff") ? "lint" : normalized.includes(" compile") ? "build" : "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  const makeKind = classifyMakeCommand(normalized);
+  if (makeKind) {
+    return { command, language: "unknown", kind: makeKind, scope: "full", costClass: "broad" };
+  }
+  if (/^(?:tox|nox)\b/.test(normalized)) {
+    return { command, language: "unknown", kind: "test", scope: "full", costClass: "broad" };
+  }
+  return {
+    command,
+    language: "unknown",
+    kind: "unknown",
+    scope: "unknown",
+    costClass: "unknown"
+  };
+}
+function resolveVerificationExitCode(command, result, options) {
+  const failureExitCode = options?.failureExitCode ?? 1;
+  const unavailableExitCode = options?.unavailableExitCode ?? 127;
+  if (result.timedOut === true) return { exitCode: 124, toolUnavailable: false };
+  if (typeof result.exitCode === "number") {
+    return { exitCode: result.exitCode, toolUnavailable: false };
+  }
+  if (result.toolUnavailable === true) {
+    return { exitCode: unavailableExitCode, toolUnavailable: true };
+  }
+  const all = [
+    result.all ?? `${String(result.stdout ?? "")}
+${String(result.stderr ?? "")}`,
+    result.shortMessage,
+    result.message
+  ].filter((value) => value !== void 0 && value !== null).map(String).join("\n");
+  const toolUnavailable = detectVerificationToolUnavailable(command, all) !== void 0;
+  return {
+    exitCode: toolUnavailable ? unavailableExitCode : failureExitCode,
+    toolUnavailable
+  };
+}
+function detectExitZeroVerifyFailure(command, output) {
+  const normalizedOutput = String(output ?? "");
+  const descriptor = describeVerificationCommand(command);
+  for (const detector of orderedExitZeroFailureDetectors(descriptor)) {
+    const signal = detector(normalizedOutput, descriptor);
+    if (signal) return signal;
+  }
+  return void 0;
+}
+function isPythonStdlibUnittestCommand(command) {
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.language !== "python" || descriptor.kind !== "test") return false;
+  const normalized = unwrapTrustedEnvPythonPathPrefix(command);
+  if (/\bpytest\b/.test(normalized)) return false;
+  return PYTHON_INTERPRETER_HEAD.test(normalized) && /\s-m\s+unittest\b/.test(normalized);
+}
+function detectZeroCollectedTests(command, output, hint) {
+  const csi = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
+  const normalizedOutput = String(output ?? "").replace(csi, "");
+  const descriptor = describeVerificationCommand(command, hint);
+  if (descriptor.kind !== "test" && descriptor.kind !== "unknown") return false;
+  if (/^\s*Ran\s+0\s+tests?\b/im.test(normalizedOutput) || /^\s*NO TESTS RAN\b/im.test(normalizedOutput) || /^\s*=+\s+no tests ran\b.*$/im.test(normalizedOutput) || /^\s*collected\s+0\s+items?\b/im.test(normalizedOutput)) {
+    return true;
+  }
+  if (descriptor.language === "go") {
+    return !/\s-run(?:\s+|=)(?:"\^\$"|'?\^\$'?)/.test(normalizeCommand(command)) && detectsGoZeroCollectedTests(normalizedOutput);
+  }
+  if (descriptor.language === "unknown") {
+    return Object.values(ZERO_COLLECTED_DETECTORS).some((detector) => detector(normalizedOutput));
+  }
+  return ZERO_COLLECTED_DETECTORS[descriptor.language]?.(normalizedOutput) ?? false;
+}
+function hasPositiveNodeRunnerSummary(output) {
+  return /^[ \t]*(?:Tests:|Test Suites:|Tests|Test Files)[ \t]+[1-9]\d*[ \t]+(?:passed|failed|skipped|todo|pending)\b/m.test(
+    output
+  );
+}
+function detectsNodeZeroCollectedTests(output) {
+  const normalized = output;
+  if (/^\s*No test files found(?:, exiting with code 0)?\s*$/im.test(normalized) && !/[1-9]\d*\s+passed\b/i.test(normalized) && !/Tests?\s*[:]?\s*[1-9]/i.test(normalized) && !/^\s*(?:\u2139\s+)?tests\s+[1-9]\d*\s*$/im.test(normalized)) {
+    return true;
+  }
+  if (/^\s*No tests found, exiting with code 0\s*$/im.test(normalized) && !hasPositiveNodeRunnerSummary(normalized)) {
+    return true;
+  }
+  if (/^\s*0\s+passing\b/im.test(normalized) && !/^\s*[1-9]\d*\s+(?:passing|failing)\b/im.test(normalized) && !/[1-9]\d*\s+passed\b/i.test(normalized) && !/Tests?\s*[:]?\s*[1-9]/i.test(normalized)) {
+    return true;
+  }
+  if (/^\s*#\s+tests\s+0\s*$/im.test(normalized)) {
+    return true;
+  }
+  return /^\s*(?:\u2139\s+)?tests\s+0\s*$/im.test(normalized) && !/^\s*(?:\u2139\s+)?tests\s+[1-9]\d*\s*$/im.test(normalized);
+}
+function detectsGoZeroCollectedTests(output) {
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const packageResultLines = lines.filter((line) => /^(?:ok|\?)\s+\S+/.test(line));
+  const coverageOnlyLines = lines.filter(
+    (line) => /^\S+\s+coverage:\s+0\.0%\s+of\s+statements\s*$/i.test(line)
+  );
+  if (packageResultLines.length === 0 && coverageOnlyLines.length > 0) return true;
+  if (packageResultLines.length === 0) return false;
+  return packageResultLines.every(
+    (line) => /\[(?:no test files|no tests to run)\]\s*$/i.test(line)
+  );
+}
+function detectsRustZeroCollectedTests(output) {
+  const runningCounts = Array.from(output.matchAll(/^\s*running\s+(\d+)\s+tests?\b/gim)).map(
+    (match) => Number(match[1] ?? 0)
+  );
+  if (runningCounts.length === 0 || runningCounts.some((count) => count > 0)) return false;
+  return !/^\s*test result:\s+ok\.\s+.*?\b[1-9]\d*\s+passed\b/im.test(output);
+}
+function detectsJvmZeroCollectedTests(output) {
+  const mavenRunCounts = Array.from(
+    output.matchAll(/^\s*(?:\[INFO\]\s*)?Tests run:\s*(\d+)\b/gim),
+    (match) => Number(match[1] ?? 0)
+  );
+  if (mavenRunCounts.length > 0) {
+    return mavenRunCounts.every((count) => count === 0);
+  }
+  if (/^\s*(?:\[INFO\]\s*)?No tests to run\.?\s*$/im.test(output)) {
+    return true;
+  }
+  const gradleTestTaskLines = output.split(/\r?\n/).map((line) => line.trim()).filter(
+    (line) => /^(?:>\s*)?Task\s+:[^\s]*test\b/i.test(line) || /^(?:>\s*)?:[^\s]*test\b/i.test(line)
+  );
+  return gradleTestTaskLines.length > 0 && gradleTestTaskLines.every((line) => /\bNO-SOURCE\b/i.test(line));
+}
+function detectsDotnetZeroCollectedTests(output) {
+  if (/^\s*(?:Passed|Failed)!\s*-\s*Failed:\s*\d+,\s*Passed:\s*\d+,\s*Skipped:\s*\d+,\s*Total:\s*[1-9]/im.test(
+    output
+  )) {
+    return false;
+  }
+  return /^\s*No test is available in\b/im.test(output) || /^\s*No test matches the given testcase filter\b/im.test(output) || /^\s*Passed!\s*-\s*Failed:\s*0,\s*Passed:\s*0,\s*Skipped:\s*\d+,\s*Total:\s*0\b/im.test(output);
+}
+function detectsRubyZeroCollectedTests(output) {
+  if (/^\s*[1-9]\d*\s+examples?,/im.test(output) || /^\s*[1-9]\d*\s+runs?,/im.test(output)) {
+    return false;
+  }
+  return /^\s*0\s+examples,\s+0\s+failures\b/im.test(output) || /^\s*0\s+runs,\s+0\s+assertions\b/im.test(output);
+}
+function detectsDartZeroCollectedTests(output) {
+  return /^\s*(?:\d{2}:\d{2}\s+\+\d+(?:\s+-\d+)?(?:\s+~\d+)?:\s*)?No tests ran\.\s*$/im.test(
+    output
+  );
+}
+function detectsSwiftZeroCollectedTests(output) {
+  if (/^\s*Executed\s+[1-9]\d*\s+tests?\b/im.test(output) || /^[^A-Za-z0-9\r\n]*Test run with\s+[1-9]\d*\s+tests?\b/im.test(output)) {
+    return false;
+  }
+  return /^\s*Executed\s+0\s+tests\b/im.test(output) || /^[^A-Za-z0-9\r\n]*Test run with\s+0\s+tests\b/im.test(output);
+}
+function detectsPhpZeroCollectedTests(output) {
+  return /^\s*No tests executed!\s*$/im.test(output);
+}
+function detectsNativeZeroCollectedTests(output) {
+  return /^\s*No tests were found!!!\s*$/im.test(output) || /^\s*No tests defined\.\s*$/im.test(output);
+}
+function detectsRZeroCollectedTests(output) {
+  if (/^\s*\[\s*FAIL\s+\d+\s*\|\s*WARN\s+\d+\s*\|\s*SKIP\s+\d+\s*\|\s*PASS\s+[1-9]\d*\s*\]/im.test(
+    output
+  )) {
+    return false;
+  }
+  return /^\s*\[\s*FAIL\s+0\s*\|\s*WARN\s+\d+\s*\|\s*SKIP\s+0\s*\|\s*PASS\s+0\s*\]\s*$/im.test(
+    output
+  );
+}
+var ZERO_COLLECTED_DETECTORS = {
+  go: detectsGoZeroCollectedTests,
+  rust: detectsRustZeroCollectedTests,
+  jvm: detectsJvmZeroCollectedTests,
+  node: detectsNodeZeroCollectedTests,
+  dotnet: detectsDotnetZeroCollectedTests,
+  ruby: detectsRubyZeroCollectedTests,
+  dart: detectsDartZeroCollectedTests,
+  swift: detectsSwiftZeroCollectedTests,
+  php: detectsPhpZeroCollectedTests,
+  native: detectsNativeZeroCollectedTests,
+  r: detectsRZeroCollectedTests,
+  shell: detectsBatsZeroCollected,
+  sql: detectsDbtZeroCollected
+};
+function selectFallbacksForCommand(primaryCommand, fallbackCommands) {
+  const primary = describeVerificationCommand(primaryCommand);
+  if (primary.kind !== "test" && primary.kind !== "unknown") return [];
+  return fallbackCommands.filter(
+    (fallback) => describeVerificationCommand(fallback).language === primary.language
+  );
+}
+var VERIFICATION_LANGUAGE_PROJECT_LANGUAGES = {
+  node: ["node", "typescript", "javascript"],
+  python: ["python"],
+  native: ["c", "cpp"],
+  go: ["go"],
+  rust: ["rust"],
+  jvm: ["java", "kotlin"],
+  dotnet: ["dotnet"],
+  swift: ["swift"],
+  dart: ["dart"],
+  ruby: ["ruby"],
+  php: ["php"],
+  shell: ["shell", "powershell"],
+  r: ["r"],
+  sql: ["sql"]
+};
+var NODE_PACKAGE_MANAGER_COMMAND_HEAD = /^(?:npm|pnpm|yarn|bun|npx|pnpx|bunx)\b/;
+function verificationCommandMatchesProjectLanguages(command, projectLanguages, options) {
+  if (NODE_PACKAGE_MANAGER_COMMAND_HEAD.test(normalizeCommand(command))) {
+    return options?.hasRootPackageManifest ?? projectLanguages.includes("node");
+  }
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.language === "unknown") return true;
+  const compatible = VERIFICATION_LANGUAGE_PROJECT_LANGUAGES[descriptor.language];
+  return compatible.some((language) => projectLanguages.includes(language));
+}
+var PRE_SPAWN_SETUP_REQUIRED = /^command not found: \S+ \(setup required: ([^\n]+)/m;
+function detectVerificationToolUnavailable(command, output, exitCode, processExitCode) {
+  const normalizedCommand = normalizeCommand(command).toLowerCase();
+  const normalizedOutput = String(output ?? "").toLowerCase();
+  const descriptor = describeVerificationCommand(command);
+  const signal = (unavailableReason) => (message) => ({
+    toolchain: descriptor.language,
+    message,
+    unavailableReason
+  });
+  const dependency = signal("dependency_missing");
+  const launcher = signal("launcher_missing");
+  const interpreterCommand = unwrapTrustedEnvPythonPathPrefix(command).toLowerCase();
+  const pythonUnavailable = PYTHON_INTERPRETER_HEAD.test(interpreterCommand) ? classifyPythonModuleUnavailable(interpreterCommand, normalizedOutput) : void 0;
+  if (pythonUnavailable === COVERAGE_NO_DATA) return signal("zero_tests")(pythonUnavailable);
+  if (pythonUnavailable) return dependency(pythonUnavailable);
+  const executable = normalizedCommand.trim().split(/\s+/)[0]?.replace(/^.*[/\\]/, "");
+  if (!executable) return void 0;
+  const commandParts = normalizedCommand.trim().split(/\s+/);
+  const subcommand = commandParts[1];
+  if (normalizedOutput.includes(`no module named ${executable}`)) {
+    return dependency(`Verification tool unavailable: module '${executable}' is not installed.`);
+  }
+  const setupGap = PRE_SPAWN_SETUP_REQUIRED.exec(String(output ?? ""))?.[1]?.replace(/\)\s*$/, "").trim();
+  if (setupGap) return dependency(`Verification tool unavailable: setup required: ${setupGap}`);
+  const launcherEvidence = launcherLinesCount(exitCode);
+  const missing = nestedMissingMessage(normalizedOutput, exitCode, executable, processExitCode);
+  if (missing) return launcher(missing);
+  const missingJvmLauncher = normalizedOutput.match(
+    /\bno ['"]?([a-z0-9_.-]+)['"]? command could be found in your path\b/i
+  )?.[1];
+  if (descriptor.language === "jvm" && missingJvmLauncher) {
+    return launcher(
+      `Verification tool unavailable: executable '${missingJvmLauncher}' was not found.`
+    );
+  }
+  const unresolved = detectMissingDependencySignature(
+    executable,
+    normalizedOutput,
+    processExitCode ?? exitCode
+  );
+  if (unresolved) return dependency(unresolved);
+  if (subcommand && outputNamesMissingSubcommand(normalizedOutput, subcommand)) {
+    return launcher(`Verification tool unavailable: subcommand '${subcommand}' is not installed.`);
+  }
+  const proxiedTool = subcommand ? `${executable}-${subcommand}` : executable;
+  if (outputNamesToolNotInstalledForToolchain(normalizedOutput, proxiedTool)) {
+    return launcher(`Verification tool unavailable: '${proxiedTool}' is not installed.`);
+  }
+  if (launcherEvidence && outputNamesInvokedNotFound(normalizedOutput, executable)) {
+    return launcher(`Verification tool unavailable: executable '${executable}' was not found.`);
+  }
+  return void 0;
+}
+
+export {
+  readShellBackslash,
+  applicableRunnerLanguages,
+  runnerRowApplies,
+  isMissingToolLaunch,
+  missingExecutableMessage,
+  wrapperReportsInnerMissingLaunch,
+  parseVerificationCommandArgv,
+  isPrettierInvocation,
+  pythonUnittestDiscoveryArgs,
+  derivePythonCoverageCommands,
+  isResolverPythonCoverageArgv,
+  parseUvRunArgv,
+  PYTHON_INTERPRETER_HEAD,
+  unwrapTrustedEnvPythonPathPrefix,
+  parseMavenTestSelectorToken,
+  extractJvmVerificationGoals,
+  describeVerificationCommand,
+  resolveVerificationExitCode,
+  detectExitZeroVerifyFailure,
+  isPythonStdlibUnittestCommand,
+  detectZeroCollectedTests,
+  selectFallbacksForCommand,
+  VERIFICATION_LANGUAGE_PROJECT_LANGUAGES,
+  verificationCommandMatchesProjectLanguages,
+  detectVerificationToolUnavailable
+};
+//# sourceMappingURL=chunk-EPAMVGI3.js.map