@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-QOFLUS24.js

@@ -0,0 +1,535 @@
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  aggregateResolverOutcomes,
+  bucketCommandOutcomes,
+  classifyResolverCommand
+} from "./chunk-6TBEX4R4.js";
+import {
+  runVerificationCommand
+} from "./chunk-S2E632FQ.js";
+import {
+  DECLARABLE_CHANNELS,
+  buildProjectVerificationGuidance,
+  buildTargetWorktreeExecutionScope
+} from "./chunk-AHU3FKPA.js";
+import {
+  describeVerificationCommand,
+  parseVerificationCommandArgv,
+  selectFallbacksForCommand
+} from "./chunk-EPAMVGI3.js";
+
+// src/core/execution/quality-gate.ts
+import { execa } from "execa";
+
+// src/core/project/coverage-gate-commands.ts
+import path from "path";
+function launcher(command) {
+  const argv = parseVerificationCommandArgv(command);
+  if (!Array.isArray(argv)) return void 0;
+  const tool = argv.find(
+    (token, index) => !(index === 0 && token === "env") && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(token)
+  );
+  return tool ? path.basename(tool) : void 0;
+}
+function coverageRunsTest(coverage, test) {
+  const coverageLanguage = describeVerificationCommand(coverage).language;
+  const testLanguage = describeVerificationCommand(test).language;
+  if (coverageLanguage !== "unknown") return coverageLanguage === testLanguage;
+  if (testLanguage === "unknown") return false;
+  const tool = launcher(coverage);
+  return tool !== void 0 && tool === launcher(test);
+}
+function coverageGateCommands(verification) {
+  const coverage = verification.coverage ?? [];
+  if (coverage.length === 0) return [];
+  const uncoveredTests = verification.test.filter(
+    (test) => !coverage.some((command) => coverageRunsTest(command, test))
+  );
+  return [...coverage, ...uncoveredTests];
+}
+
+// src/core/execution/quality-gate.ts
+function isTestEvidenceGate(gate) {
+  return gate === "coverage" || gate === "tests";
+}
+function isTestEvidenceGateResult(gate, notMeasured) {
+  return isTestEvidenceGate(gate) && notMeasured !== true;
+}
+function testEvidenceGateId(results) {
+  return results.some((result) => result.gate === "tests") ? "tests" : "coverage";
+}
+var NON_BLOCKING_QUALITY_GATE_SKIP_MARKERS = [
+  "skipped by configuration",
+  "not applicable to this target",
+  // Legacy Node applicability-skip markers (no longer emitted by the runner;
+  // retained for defensive back-compat — see doc above).
+  "package.json not found",
+  "no supported lockfile",
+  "has no typecheck script",
+  "has no test:coverage script",
+  "packagemanager is"
+];
+var NodeCommandRunner = class {
+  async run(command, args, options = {}) {
+    const start = Date.now();
+    const result = await execa(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      timeout: options.timeoutMs,
+      reject: false,
+      all: false
+    });
+    return {
+      exitCode: result.exitCode ?? null,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      timedOut: result.timedOut,
+      durationMs: Date.now() - start
+    };
+  }
+};
+var QualityGateRunner = class {
+  /**
+   * The constructor still accepts an injectable {@link CommandRunner} for API
+   * compatibility, but post-collapse the runner NO LONGER dispatches any command
+   * through it: every gate flows through the resolver-backed path, which executes
+   * via `runVerificationCommand`. An injected runner is therefore never invoked
+   * (tests rely on this to assert the old hardcoded Node path is dead). The
+   * parameter is intentionally unused.
+   */
+  // biome-ignore lint/complexity/noUselessConstructor: retained for API/test compatibility; the injectable runner is intentionally never invoked post-collapse (proves the hardcoded Node path is dead).
+  constructor(_commandRunner = new NodeCommandRunner()) {
+  }
+  /**
+   * Execute the configured set of quality gates and report the overall outcome.
+   *
+   * SINGLE PATH: every target language —
+   * Node and non-Node alike — flows through the resolver-backed path. Commands
+   * are read from the language-neutral resolver
+   * ({@link ProjectCapabilities.verification}, never hardcoded) and classified by
+   * the single fail-closed classifier {@link classifyResolverCommand}. The former
+   * Node fork (hardcoded `npm run test:coverage` / `npm run typecheck` /
+   * `npm audit` gates, evaluated by their own exit-code/JSON logic) is gone.
+   */
+  async run(options = {}) {
+    const requestedSteps = buildRequestedGateSteps(options);
+    const results = [];
+    const cwd = options.cwd ?? process.cwd();
+    const scopeResult = buildTargetWorktreeExecutionScope({
+      root: cwd,
+      confirmedRoot: true
+    });
+    if (scopeResult.status === "fail") {
+      for (const step of requestedSteps) {
+        results.push(createScopeFailureResult(step, scopeResult.reason));
+      }
+      return { success: false, results };
+    }
+    if (scopeResult.status === "unavailable") {
+      for (const step of requestedSteps) {
+        results.push(createUnavailableResult(step.id, cwd, scopeResult.reason));
+      }
+      return { success: this.summarizeSuccess(results), results };
+    }
+    const capabilities = scopeResult.value.capabilities;
+    const resolverResults = await this.runResolverBackedGates(capabilities, cwd, options);
+    return {
+      success: this.summarizeSuccess(resolverResults),
+      results: resolverResults
+    };
+  }
+  /**
+   * Run REAL verification gates for ANY target language using resolver-derived
+   * commands, fail-closed. This is the SINGLE [B6] language-neutral path (no Node
+   * fork): commands are read from {@link ProjectCapabilities.verification} (never
+   * hardcoded) and classified by the single fail-closed classifier
+   * {@link classifyResolverCommand} (which mirrors the deterministic test gate,
+   * src/core/judge/test-gate.ts runCapabilityTestCommand).
+   *
+   * Gate-id mapping onto the {@link QualityGateId} union:
+   *  - `coverage` <- resolver `coverage` bucket ONLY (Node's
+   *    `npm run test:coverage`, Go's `go test -cover`, ...). When that bucket is
+   *    empty coverage was NEVER MEASURED, so the gate is reported `not-measured`
+   *    ({@link createNotMeasuredResult}) rather than borrowing the test run: a
+   *    passing test suite is not evidence about coverage, in either direction.
+   *  - `tests` <- primary `test` bucket (+`testFallback`), emitted only when the
+   *    `coverage` bucket is empty (a coverage command already runs the suite). This
+   *    preserves the pre-collapse non-Node behavior — a pytest/go-test project with
+   *    no dedicated coverage command still verifies via its `test` runner and still
+   *    contributes an EXECUTED gate to the run — while keeping test evidence under
+   *    a test gate id. {@link isTestEvidenceGate} / {@link testEvidenceGateId} are
+   *    the supported way for consumers to find that evidence.
+   *  - `lint` <- resolver `lint` + `typecheck` + `format` (static-analysis family).
+   *  - `security` <- resolver `audit` bucket (Node `npm audit ...`, Go
+   *    `govulncheck`, Rust `cargo audit`, Python `pip-audit`). The audit command's
+   *    pass/fail is decided by the SAME exit-code classifier as every other
+   *    command. ENUMERATED INTENTIONAL DIFFERENCE vs the deleted hardcoded Node
+   *    security gate: that gate produced a richer per-severity summary message via
+   *    parseSecurityOutput, whereas the classifier emits a generic message. The
+   *    PASS/FAIL verdict is byte-identical because `npm audit --audit-level=high`
+   *    exits NONZERO iff a high/critical (blocking) vulnerability exists (low/
+   *    moderate -> exit 0), exactly the blocking-count condition parseSecurityOutput
+   *    enforced. The audit JSON is preserved on the gate result's `stdout`, so the
+   *    downstream {@link countBlockingVulnerabilities} consumer
+   *    (autonomous-loop-controller security-regression count) keeps working.
+   *
+   * Per-gate aggregation (a gate id may collect several resolver commands, e.g.
+   * lint+typecheck both map to `lint`) is FAIL-CLOSED for the whole bucket: every
+   * command is executed with a shared remaining timeout budget. Dominance order
+   * (A8): real failure/error > timeout > unavailable > passed. The gate FAILS if
+   * any command ran-and-failed; else TIMEOUT if any timed out / budget exhausted;
+   * else UNAVAILABLE if ANY command is tool-unavailable (a required verification
+   * kind we could not run cannot be certified — a passing ruff must not mask an
+   * unavailable mypy); it PASSES only when EVERY command ran and passed.
+   *
+   * Honesty contract for an ABSENT bucket: when a requested gate has NO resolver
+   * command (e.g. a Node project with no test:coverage script, a docs-only target,
+   * a pnpm project that cannot run `npm audit`), the gate is emitted as
+   * {@link createUnavailableResult} ({ skipped:true, unavailable:true,
+   * success:false }) — never a silent pass. summarizeSuccess (>=1 EXECUTED gate
+   * that succeeded) therefore drives the overall run FALSE for an all-unavailable
+   * target, preserving the pre-collapse fail-closed outcome.
+   *
+   * Caller gate-skip options are honored: options.coverage/lint/security === false
+   * emits a success:true skipped entry (createSkippedResult) and the corresponding
+   * bucket is NOT run, so summarizeSuccess filters it out (neither passes nor fails
+   * the run). `options.coverage === false` disables the whole test/coverage family
+   * (neither the coverage nor the tests bucket is dispatched), exactly as it did
+   * when both shared one gate id.
+   *
+   * The `tests` bucket honors the resolver `testFallback` contract: a fallback
+   * command is tried ONLY when the primary `test` command reports its tool
+   * unavailable; fallbacks are never additional gates. Fallback never applies to
+   * the dedicated coverage bucket.
+   */
+  async runResolverBackedGates(capabilities, cwd, options) {
+    const verification = capabilities.verification;
+    const results = [];
+    let remainingTimeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(0, Math.floor(options.timeoutMs)) : void 0;
+    const runOne = async (command, testRole) => {
+      if (options.abortSignal?.aborted || remainingTimeoutMs !== void 0 && remainingTimeoutMs <= 0) {
+        return {
+          // Shared channel/run budget exhausted: timeout tier (never a pass), ranked
+          // below real failures and above unavailable in aggregate dominance.
+          classification: options.abortSignal?.aborted ? "failed" : "timeout",
+          command,
+          message: options.abortSignal?.aborted ? "Resolver gate skipped: run cancelled." : "Resolver gate skipped: autoloop timebox exhausted.",
+          stdout: "",
+          stderr: "",
+          durationMs: 0,
+          parsed: false
+        };
+      }
+      const stepTimeoutMs = remainingTimeoutMs !== void 0 ? Math.max(1, remainingTimeoutMs) : void 0;
+      const start = Date.now();
+      try {
+        const result = await runVerificationCommand(command, {
+          cwd,
+          timeoutMs: stepTimeoutMs,
+          abortSignal: options.abortSignal
+        });
+        const durationMs = Date.now() - start;
+        if (remainingTimeoutMs !== void 0) {
+          remainingTimeoutMs = Math.max(0, remainingTimeoutMs - durationMs);
+        }
+        const bucket = testRole ? "test" : void 0;
+        return classifyResolverCommand(command, result, durationMs, { bucket });
+      } catch (error) {
+        const durationMs = Date.now() - start;
+        if (remainingTimeoutMs !== void 0) {
+          remainingTimeoutMs = Math.max(0, remainingTimeoutMs - durationMs);
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+          classification: "failed",
+          command,
+          message: `Verification command "${command}" threw before completing: ${detail}`,
+          stdout: "",
+          stderr: detail,
+          durationMs,
+          parsed: false
+        };
+      }
+    };
+    const coverageCommands = coverageGateCommands(verification);
+    const testCommands = coverageCommands.length > 0 ? [] : verification.test;
+    const lintCommands = [...verification.lint, ...verification.typecheck, ...verification.format];
+    const auditCommands = verification.audit ?? [];
+    const anyGateHasCommands = coverageCommands.length > 0 || testCommands.length > 0 || lintCommands.length > 0 || auditCommands.length > 0;
+    const runBucket = async (gate, commands, allowFallback) => {
+      const outcomes = [];
+      for (const command of commands) {
+        let outcome = await runOne(command, verification.test.includes(command));
+        if (allowFallback && outcome.classification === "unavailable") {
+          const fallbacks = selectFallbacksForCommand(command, verification.testFallback);
+          for (const fallback of fallbacks) {
+            const fallbackOutcome = await runOne(fallback, true);
+            if (fallbackOutcome.classification !== "unavailable") {
+              outcome = fallbackOutcome;
+              break;
+            }
+          }
+        }
+        outcomes.push(outcome);
+      }
+      return aggregateResolverGate(gate, outcomes);
+    };
+    if (options.coverage === false) {
+      results.push(
+        createSkippedResult("coverage", "Test coverage check skipped by configuration.")
+      );
+    } else {
+      if (coverageCommands.length > 0) {
+        results.push(await runBucket("coverage", coverageCommands, false));
+      } else if (testCommands.length > 0) {
+        results.push(createNotMeasuredResult("coverage", cwd));
+      } else if (!anyGateHasCommands) {
+        results.push(createUnavailableResult("coverage", cwd, void 0, true));
+      }
+      if (testCommands.length > 0) {
+        results.push(await runBucket("tests", testCommands, true));
+      }
+    }
+    const uncovered = capabilities.shellLintUncovered;
+    if (options.lint === false) {
+      results.push(createSkippedResult("lint", "Linting skipped by configuration."));
+    } else if (lintCommands.length > 0) {
+      const outcomes = [];
+      for (const command of lintCommands) {
+        outcomes.push(await runOne(command, false));
+      }
+      const lintGate = aggregateResolverGate("lint", outcomes);
+      if (verification.typecheck.length === 0) lintGate.styleOnly = true;
+      results.push(withUncoveredFiles(lintGate, uncovered));
+    } else if (!anyGateHasCommands) {
+      results.push(
+        withUncoveredFiles(createUnavailableResult("lint", cwd, void 0, true), uncovered)
+      );
+    } else if (uncovered && uncovered.length > 0) {
+      results.push(withUncoveredFiles(createNotMeasuredResult("lint", cwd), uncovered));
+    }
+    if (options.security === false) {
+      results.push(createSkippedResult("security", "Security audit skipped by configuration."));
+    } else if (auditCommands.length > 0) {
+      const outcomes = [];
+      for (const command of auditCommands) {
+        outcomes.push(await runOne(command, false));
+      }
+      results.push(aggregateResolverGate("security", outcomes));
+    } else if (anyGateHasCommands) {
+      if (options.securityNotModeled === "not-applicable") {
+        results.push({
+          ...createSkippedResult(
+            "security",
+            "Security audit not applicable to this target: no audit command was detected."
+          ),
+          notApplicable: true
+        });
+      } else if (options.security === true) {
+        results.push(
+          createUnavailableResult("security", cwd, "no security audit command was detected", true)
+        );
+      } else {
+        results.push(createNotMeasuredResult("security", cwd));
+      }
+    } else if (!anyGateHasCommands) {
+      results.push(createUnavailableResult("security", cwd, void 0, true));
+    }
+    return results;
+  }
+  summarizeSuccess(results) {
+    const executedResults = results.filter((res) => res.skipped !== true);
+    return executedResults.length > 0 && results.every((res) => res.success);
+  }
+};
+function buildRequestedGateSteps(options) {
+  const npmCommand = getNpmCommand();
+  const steps = [];
+  if (options.coverage !== false) {
+    steps.push({
+      id: "coverage",
+      title: "Test Coverage",
+      command: npmCommand,
+      args: ["run", "test:coverage"],
+      description: "Run the test suite with coverage reporting."
+    });
+  }
+  if (options.lint !== false) {
+    steps.push({
+      id: "lint",
+      title: "Static Analysis",
+      command: npmCommand,
+      args: ["run", "typecheck"],
+      description: "Type-driven linting using the project TypeScript configuration."
+    });
+  }
+  if (options.security !== false) {
+    steps.push({
+      id: "security",
+      title: "Dependency Security Audit",
+      command: npmCommand,
+      args: ["audit", "--omit=dev", "--audit-level=high", "--json"],
+      description: "Check production dependencies for known vulnerabilities using npm audit."
+    });
+  }
+  return steps;
+}
+function isSeverityBlocking(level) {
+  const normalized = level.toLowerCase();
+  return normalized === "critical" || normalized === "high";
+}
+function countBlockingVulnerabilities(stdout) {
+  const output = stdout.trim();
+  if (!output) {
+    return null;
+  }
+  try {
+    const parsed = parseJsonWithContext(output, "security scan output");
+    const parsedObj = parsed;
+    const metadata = parsedObj?.metadata;
+    const vulnerabilities = metadata?.vulnerabilities;
+    if (!vulnerabilities) {
+      return null;
+    }
+    return Object.entries(vulnerabilities).reduce((acc, [level, count]) => {
+      const numeric = typeof count === "number" && Number.isFinite(count) ? count : 0;
+      return isSeverityBlocking(level) ? acc + numeric : acc;
+    }, 0);
+  } catch {
+    return null;
+  }
+}
+function getNpmCommand() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function aggregateResolverGate(gate, outcomes) {
+  const aggregate = aggregateResolverOutcomes(outcomes);
+  const representative = aggregate.representative;
+  if (aggregate.classification === "failed" || aggregate.classification === "timeout") {
+    return {
+      gate,
+      success: false,
+      message: representative?.message ?? (aggregate.classification === "timeout" ? `Resolver ${gate} gate timed out.` : `Resolver ${gate} gate failed.`),
+      command: representative?.command ?? "",
+      args: [],
+      stdout: representative?.stdout ?? "",
+      stderr: representative?.stderr ?? "",
+      durationMs: representative?.durationMs ?? 0,
+      failedCommands: bucketCommandOutcomes(outcomes)
+    };
+  }
+  if (aggregate.classification === "unavailable") {
+    const zeroTestsNoEvidence = outcomes.some((outcome) => outcome.zeroTestsNoEvidence === true) || representative?.zeroTestsNoEvidence === true;
+    return {
+      gate,
+      success: false,
+      skipped: true,
+      unavailable: true,
+      zeroTestsNoEvidence: zeroTestsNoEvidence || void 0,
+      message: representative ? representative.message : `Resolver ${gate} gate unavailable: no verification tool was found.`,
+      command: representative?.command ?? "",
+      args: [],
+      stdout: representative?.stdout ?? "",
+      stderr: representative?.stderr ?? "",
+      durationMs: representative?.durationMs ?? 0
+    };
+  }
+  return {
+    gate,
+    success: true,
+    message: representative?.message ?? `Resolver ${gate} gate passed.`,
+    command: representative?.command ?? "",
+    args: [],
+    stdout: representative?.stdout ?? "",
+    stderr: representative?.stderr ?? "",
+    durationMs: representative?.durationMs ?? 0
+  };
+}
+function withUncoveredFiles(result, uncoveredFiles) {
+  if (!uncoveredFiles || uncoveredFiles.length === 0) {
+    return result;
+  }
+  return { ...result, uncoveredFiles: [...uncoveredFiles] };
+}
+function createSkippedResult(gate, message) {
+  return {
+    gate,
+    success: true,
+    skipped: true,
+    message,
+    command: "",
+    args: [],
+    stdout: "",
+    stderr: "",
+    durationMs: 0
+  };
+}
+function createNotMeasuredResult(gate, cwd) {
+  let detail = "";
+  try {
+    const guidance = buildProjectVerificationGuidance(cwd);
+    detail = ` Detected target languages: ${guidance.capabilities.languages.join(", ")}.`;
+  } catch {
+    detail = "";
+  }
+  return {
+    ...createSkippedResult(
+      gate,
+      `${capitalizeGateId(gate)} gate not applicable to this target: no ${gate} command was detected, so ${gate} was never measured.${detail}`
+    ),
+    notMeasured: true
+  };
+}
+function createScopeFailureResult(step, reason) {
+  return {
+    gate: step.id,
+    success: false,
+    message: `Quality gate scope setup failed: ${reason}`,
+    command: step.command,
+    args: step.args,
+    stdout: "",
+    stderr: "",
+    durationMs: 0
+  };
+}
+function createUnavailableResult(gate, cwd, reason = "target project is not a Node package", notApplicable = false) {
+  let detail;
+  try {
+    const guidance = buildProjectVerificationGuidance(cwd);
+    const languages = guidance.capabilities.languages.join(", ");
+    const commandSummary = guidance.commands.length > 0 ? `Detected verification commands: ${guidance.commands.slice(0, 3).map((command) => command.command).join("; ")}${guidance.commands.length > 3 ? "; ..." : ""}.` : `No deterministic verification command was detected. Hint: declare one in .build-project/config/build.config.jsonc under a "verification" object (keys: ${DECLARABLE_CHANNELS.join(", ")}; each a string or array of strings), e.g. verification.test, so Build can run it automatically.`;
+    detail = `Detected target languages: ${languages}. ${commandSummary}`;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    detail = `Project verification guidance unavailable: ${message}`;
+  }
+  return {
+    gate,
+    success: false,
+    skipped: true,
+    unavailable: true,
+    ...notApplicable ? { notApplicable: true } : {},
+    message: `${capitalizeGateId(gate)} gate unavailable: ${reason}. ${detail}`,
+    command: "",
+    args: [],
+    stdout: "",
+    stderr: "",
+    durationMs: 0
+  };
+}
+function capitalizeGateId(gate) {
+  return gate.charAt(0).toUpperCase() + gate.slice(1);
+}
+
+export {
+  isTestEvidenceGate,
+  isTestEvidenceGateResult,
+  testEvidenceGateId,
+  NON_BLOCKING_QUALITY_GATE_SKIP_MARKERS,
+  NodeCommandRunner,
+  QualityGateRunner,
+  countBlockingVulnerabilities
+};
+//# sourceMappingURL=chunk-QOFLUS24.js.map

package/dist/chunk-QOIASNEJ.js

@@ -0,0 +1,98 @@
+// src/core/project/tool-output-dirs.ts
+var TOOL_OUTPUT_DIRS = [
+  // Dependency and cache trees: never first-party, at any depth.
+  { path: "node_modules", scope: "anywhere" },
+  // npm, pnpm, yarn
+  { path: ".venv", scope: "anywhere" },
+  // Python virtualenvs
+  { path: "venv", scope: "anywhere" },
+  { path: "__pycache__", scope: "anywhere" },
+  // Terraform's generated provider/module cache. A checkout containing only
+  // `.terraform/modules/.../*.tf` cache files must not be detected as a
+  // Terraform project; only first-party `*.tf` outside it counts.
+  { path: ".terraform", scope: "anywhere" },
+  { path: "dist-newstyle", scope: "anywhere" },
+  // cabal
+  { path: ".stack-work", scope: "anywhere" },
+  // stack
+  { path: ".zig-cache", scope: "anywhere" },
+  // zig
+  { path: "zig-out", scope: "anywhere" },
+  { path: ".gradle", scope: "anywhere" },
+  // Gradle project state
+  { path: ".kotlin", scope: "anywhere" },
+  // Kotlin Gradle plugin state
+  { path: ".build", scope: "anywhere" },
+  // SwiftPM
+  { path: ".bsp", scope: "anywhere" },
+  // sbt / Bloop build-server state
+  // Names an author may also give a source directory: leading segment only.
+  { path: "dist", scope: "root", manifests: ["package.json", "pyproject.toml", "setup.py"] },
+  {
+    path: "build",
+    scope: "root",
+    manifests: ["build.gradle", "build.gradle.kts", "CMakeLists.txt", "pyproject.toml", "setup.py"]
+  },
+  // Cargo, Maven, sbt (including sbt 2 `target/out`)
+  { path: "target", scope: "root", manifests: ["Cargo.toml", "pom.xml", "build.sbt"] },
+  { path: "vendor", scope: "root", manifests: ["go.mod", "composer.json", "Gemfile"] },
+  { path: "_build", scope: "root", manifests: ["mix.exs", "dune-project"] },
+  // mix, dune
+  { path: "project/target", scope: "root" }
+  // sbt meta-build
+];
+var TOOL_OUTPUT_DIR_NAMES = TOOL_OUTPUT_DIRS.filter(
+  (dir) => !dir.path.includes("/")
+).map((dir) => dir.path);
+var TOOL_OUTPUT_ANYWHERE_NAMES = new Set(
+  TOOL_OUTPUT_DIRS.filter((dir) => dir.scope === "anywhere").map((dir) => dir.path)
+);
+var TOOL_OUTPUT_ROOT_DIR_PATHS = TOOL_OUTPUT_DIRS.filter(
+  (dir) => dir.scope === "root"
+).map((dir) => dir.path);
+var TOOL_OUTPUT_ROOT_PREFIXES = TOOL_OUTPUT_DIRS.flatMap((dir) => [
+  `${dir.path}/`,
+  dir.path
+]);
+function isUnderAnywhereToolOutputDir(relativePath) {
+  return relativePath.replace(/\\/g, "/").split("/").some((segment) => TOOL_OUTPUT_ANYWHERE_NAMES.has(segment));
+}
+var ROOT_SCOPE_MANIFESTS = new Map(
+  TOOL_OUTPUT_DIRS.filter((dir) => dir.scope === "root" && dir.manifests).map((dir) => [
+    dir.path,
+    dir.manifests ?? []
+  ])
+);
+function nestedToolOutputCandidates(relativePath) {
+  const segments = relativePath.replace(/\\/g, "/").replace(/^\.\//, "").split("/");
+  const candidates = [];
+  for (let index = 1; index < segments.length - 1; index++) {
+    const manifests = ROOT_SCOPE_MANIFESTS.get(segments[index] ?? "");
+    if (manifests) candidates.push({ dir: segments.slice(0, index + 1).join("/"), manifests });
+  }
+  return candidates;
+}
+function isUnderNestedToolOutputDir(relativePath, probe, assumedPresent) {
+  const confirm = probe?.isNestedToolOutputDir;
+  if (!confirm) return false;
+  return nestedToolOutputCandidates(relativePath).some(
+    (candidate) => confirm.call(probe, candidate, assumedPresent)
+  );
+}
+function isUnderRootToolOutputDir(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  return TOOL_OUTPUT_ROOT_DIR_PATHS.some(
+    (dir) => normalized === dir || normalized.startsWith(`${dir}/`)
+  ) || nestedToolOutputCandidates(normalized).length > 0;
+}
+
+export {
+  TOOL_OUTPUT_DIR_NAMES,
+  TOOL_OUTPUT_ANYWHERE_NAMES,
+  TOOL_OUTPUT_ROOT_DIR_PATHS,
+  TOOL_OUTPUT_ROOT_PREFIXES,
+  isUnderAnywhereToolOutputDir,
+  isUnderNestedToolOutputDir,
+  isUnderRootToolOutputDir
+};
+//# sourceMappingURL=chunk-QOIASNEJ.js.map