@fairfox/polly 0.79.0 → 0.81.0

package/dist/tools/mutate/src/run.d.ts

@@ -0,0 +1,11 @@
+import type { MutateConfig } from "./config.ts";
+/** Run Stryker against the resolved config. Inherits stdio for the live reporter; returns the exit code. */
+export declare function runStryker(cfg: MutateConfig): Promise<number>;
+/** Build the useless-test report from an existing mutation.json (no Stryker run). */
+export declare function reportFromFile(cfg: MutateConfig): Promise<string>;
+/**
+ * If the Stryker config doesn't already load polly's verify-primitive ignorer,
+ * return a one-line tip. The ignorer must be in the config before the run (it's
+ * read at Stryker startup), so this advises rather than mutating the user's config.
+ */
+export declare function presetAdvisory(cfg: MutateConfig): Promise<string | null>;

package/dist/tools/mutate/src/verify-matrix.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Verification artefact for the kill-matrix contract.
+ *
+ * The whole useless-test analysis rests on one fact: the patched bun runner
+ * emits a COMPLETE kill matrix — every test that detects a mutant appears in
+ * killedBy, not just the first. That depends on a pinned pair: (Bun version,
+ * plugin version + our patch). A Bun upgrade that changes JUnit output, or a
+ * patch that stops applying, would silently collapse killedBy to one id each —
+ * a green board with the redundancy signal quietly dead (the classic trap).
+ *
+ * `verifyMatrix` runs the full contract and returns the result; `isMatrixComplete`
+ * is the side-effect-free gate the report path consults to decide whether the
+ * redundancy/subsumption sections are trustworthy. Run the CLI form after any
+ * bump of Bun or the plugin:
+ *
+ *   polly mutate verify          # uses the existing report
+ *   polly mutate verify --run    # runs stryker first
+ */
+import { type MutationReport } from "./ingest.ts";
+export interface MatrixCheck {
+    ok: boolean;
+    checks: {
+        name: string;
+        ok: boolean;
+        detail: string;
+    }[];
+}
+/**
+ * Side-effect-free gate: is the kill matrix trustworthy for redundancy /
+ * subsumption analysis? True only when
+ *   (a) some killed mutant has >1 killer — proof the no-bail patched runner
+ *       recorded EVERY killer, not just the first (verifyMatrix check #4), and
+ *   (b) coverage was collected — not every mutant is NoCoverage, which would
+ *       mean the coverage dump broke (verifyMatrix check #5).
+ * Without both, REDUNDANCY/SUBSUMED would be computed off a partial matrix and
+ * lie, so the report path falls back to score + gaps + theatre only.
+ */
+export declare function isMatrixComplete(report: MutationReport): boolean;
+/**
+ * Run the full kill-matrix contract (all five checks), optionally running a
+ * fresh Stryker pass first. Returns the result rather than exiting, so callers
+ * decide what to do with it; the `import.meta.main` wrapper prints and sets the
+ * exit code.
+ */
+export declare function verifyMatrix(opts?: {
+    reportPath?: string;
+    run?: boolean;
+    strykerConfig?: string;
+}): Promise<MatrixCheck>;

package/dist/tools/test/src/coverage-policy/cli.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+/**
+ * @fairfox/polly/test/coverage — consumer-facing `polly coverage`.
+ *
+ * Zero-config: run it in any Polly project and it reports per-file coverage,
+ * orphan source files, and (if a Stryker config is present) dead mutate/test
+ * globs. Add a `coverage.config.ts` with a `defaultThreshold` to turn the
+ * report into an enforced gate, and `exempt` entries to record which
+ * higher-tier test covers a unit-thin file.
+ *
+ * Usage:
+ *   polly coverage                 # report (zero-config) or enforce (with config)
+ *   polly coverage --strict-orphans  # fail on source no unit test imports
+ *   polly coverage --orphans         # list the orphan files
+ *   polly coverage --no-mutate       # skip the Stryker target check
+ *   polly coverage --config <path>   # explicit coverage.config.ts
+ *   bun test --coverage | polly coverage --stdin
+ */
+export {};

package/dist/tools/test/src/coverage-policy/cli.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env bun
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// tools/test/src/coverage-policy/enforce.ts
+var exports_enforce = {};
+__export(exports_enforce, {
+  runCoverage: () => runCoverage,
+  parseCoverageTable: () => parseCoverageTable,
+  hasFailure: () => hasFailure,
+  evaluateCoverage: () => evaluateCoverage,
+  enforceCoverage: () => enforceCoverage
+});
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+import { Glob } from "bun";
+function normalizePath(raw) {
+  return raw.replace(/^(?:\.\.\/)+/, "");
+}
+function parseCoverageTable(text, srcDir) {
+  const prefix = `${srcDir}/`;
+  const rows = [];
+  for (const line of text.split(`
+`)) {
+    if (!line.includes("|"))
+      continue;
+    if (line.includes("All files") || line.includes("% Funcs"))
+      continue;
+    if (line.trim().startsWith("---"))
+      continue;
+    const cells = line.split("|").map((c) => c.trim());
+    if (cells.length < 3)
+      continue;
+    const file = normalizePath(cells[0] ?? "");
+    const funcs = Number(cells[1]);
+    const lines = Number(cells[2]);
+    if (!file.startsWith(prefix) || Number.isNaN(funcs) || Number.isNaN(lines))
+      continue;
+    rows.push({ file, funcs, lines });
+  }
+  return rows;
+}
+async function runCoverage(root, testCwd) {
+  const proc = Bun.spawn(["bun", "test", "--coverage"], {
+    cwd: join2(root, testCwd),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [out, err] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  await proc.exited;
+  if (proc.exitCode !== 0) {
+    throw new Error(`bun test --coverage exited ${proc.exitCode}
+${err}`);
+  }
+  return `${out}
+${err}`;
+}
+function evaluateRows(rows, config) {
+  const t = config.defaultThreshold;
+  const exempt = config.exempt ?? {};
+  const violations = [];
+  const staleExempts = [];
+  if (!t)
+    return { violations, staleExempts };
+  for (const row of rows) {
+    if (exempt[row.file]) {
+      if (row.lines >= t.lines && row.funcs >= t.funcs)
+        staleExempts.push(row.file);
+      continue;
+    }
+    if (row.lines < t.lines) {
+      violations.push({ file: row.file, metric: "lines", observed: row.lines, required: t.lines });
+    }
+    if (row.funcs < t.funcs) {
+      violations.push({ file: row.file, metric: "funcs", observed: row.funcs, required: t.funcs });
+    }
+  }
+  return { violations, staleExempts };
+}
+function validateExemptions(root, config) {
+  const missingExemptFiles = [];
+  const missingClaimedBy = [];
+  for (const [file, entry] of Object.entries(config.exempt ?? {})) {
+    if (!existsSync2(resolve2(root, file)))
+      missingExemptFiles.push(file);
+    const claimedBy = entry.claimedBy.trim();
+    if (!claimedBy.startsWith("n/a") && !existsSync2(resolve2(root, claimedBy))) {
+      missingClaimedBy.push({ file, claimedBy });
+    }
+  }
+  return { missingExemptFiles, missingClaimedBy };
+}
+async function findOrphans(root, srcDir, covered, config) {
+  const exempt = config.exempt ?? {};
+  const orphans = [];
+  const glob = new Glob(`${srcDir}/**/*.{ts,tsx}`);
+  for await (const file of glob.scan({ cwd: root, onlyFiles: true })) {
+    if (file.endsWith(".d.ts") || /\.test\.tsx?$/.test(file) || file.includes("/__tests__/")) {
+      continue;
+    }
+    if (covered.has(file) || exempt[file])
+      continue;
+    orphans.push(file);
+  }
+  return orphans.sort();
+}
+async function evaluateCoverage(root, rows, config) {
+  const srcDir = config.srcDir ?? DEFAULT_SRC;
+  const { violations, staleExempts } = evaluateRows(rows, config);
+  const { missingExemptFiles, missingClaimedBy } = validateExemptions(root, config);
+  const orphans = await findOrphans(root, srcDir, new Set(rows.map((r) => r.file)), config);
+  return {
+    rowCount: rows.length,
+    violations,
+    staleExempts,
+    missingExemptFiles,
+    missingClaimedBy,
+    orphans,
+    enforced: config.defaultThreshold !== undefined
+  };
+}
+async function enforceCoverage(root, config, coverageText) {
+  const srcDir = config.srcDir ?? DEFAULT_SRC;
+  const text = coverageText ?? await runCoverage(root, config.testCwd ?? ".");
+  const rows = parseCoverageTable(text, srcDir);
+  return evaluateCoverage(root, rows, config);
+}
+function hasFailure(findings, strictOrphans) {
+  return findings.violations.length > 0 || findings.staleExempts.length > 0 || findings.missingExemptFiles.length > 0 || findings.missingClaimedBy.length > 0 || strictOrphans && findings.orphans.length > 0;
+}
+var DEFAULT_SRC = "src";
+var init_enforce = () => {};
+
+// tools/test/src/coverage-policy/discover.ts
+import { existsSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+function isCoverageConfig(value) {
+  return typeof value === "object" && value !== null;
+}
+async function importConfig(path) {
+  const mod = await import(path);
+  const candidate = mod["config"] ?? mod["default"];
+  if (!isCoverageConfig(candidate)) {
+    throw new Error(`${path} must export \`config\` (a CoverageConfig object)`);
+  }
+  return candidate;
+}
+async function loadCoverageConfig(root, explicitPath) {
+  if (explicitPath) {
+    const abs = isAbsolute(explicitPath) ? explicitPath : resolve(root, explicitPath);
+    if (!existsSync(abs))
+      throw new Error(`coverage config not found: ${abs}`);
+    return { config: await importConfig(abs), source: abs };
+  }
+  for (const name of ["coverage.config.ts", "coverage.config.js"]) {
+    const abs = join(root, name);
+    if (existsSync(abs))
+      return { config: await importConfig(abs), source: abs };
+  }
+  return { config: {}, source: null };
+}
+
+// tools/test/src/coverage-policy/cli.ts
+init_enforce();
+
+// tools/test/src/coverage-policy/mutate-targets.ts
+import { existsSync as existsSync3, readFileSync } from "node:fs";
+import { join as join3, resolve as resolve3 } from "node:path";
+import { Glob as Glob2 } from "bun";
+async function findStrykerConfigs(root) {
+  const found = [];
+  const single = join3(root, "stryker.conf.json");
+  if (existsSync3(single))
+    found.push(single);
+  const glob = new Glob2("stryker/*.{json,conf.json}");
+  for await (const rel of glob.scan({ cwd: root, onlyFiles: true })) {
+    found.push(join3(root, rel));
+  }
+  return found.sort();
+}
+function isGlob(pattern) {
+  return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+}
+async function resolvesToFile(pattern, cwd) {
+  if (pattern.startsWith("!"))
+    return true;
+  if (!isGlob(pattern))
+    return existsSync3(resolve3(cwd, pattern));
+  const glob = new Glob2(pattern);
+  for await (const _ of glob.scan({ cwd, onlyFiles: true }))
+    return true;
+  return false;
+}
+async function checkField(configPath, field, patterns, cwd) {
+  const issues = [];
+  for (const pattern of patterns ?? []) {
+    if (!await resolvesToFile(pattern, cwd)) {
+      issues.push({ config: configPath, field, pattern });
+    }
+  }
+  return issues;
+}
+async function validateMutateTargets(root) {
+  const configs = await findStrykerConfigs(root);
+  const issues = [];
+  for (const configPath of configs) {
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    const testFiles = config.testFiles ?? config.bun?.testFiles;
+    issues.push(...await checkField(configPath, "mutate", config.mutate, root));
+    issues.push(...await checkField(configPath, "testFiles", testFiles, root));
+  }
+  return { configs, issues };
+}
+
+// tools/test/src/coverage-policy/cli.ts
+function parseArgs(argv) {
+  const flag = (name) => argv.includes(name);
+  const argValue = (name) => {
+    const i = argv.indexOf(name);
+    return i >= 0 ? argv[i + 1] : undefined;
+  };
+  const strictOrphans = flag("--strict-orphans");
+  return {
+    root: process.cwd(),
+    configPath: argValue("--config"),
+    strictOrphans,
+    listOrphans: strictOrphans || flag("--orphans"),
+    stdin: flag("--stdin"),
+    mutate: !flag("--no-mutate"),
+    help: flag("--help") || flag("-h")
+  };
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of Bun.stdin.stream())
+    chunks.push(new TextDecoder().decode(chunk));
+  return chunks.join("");
+}
+function reportPolicy(f) {
+  for (const m of f.missingExemptFiles) {
+    process.stderr.write(`❌ exempt source missing: ${m}
+`);
+  }
+  for (const { file, claimedBy } of f.missingClaimedBy) {
+    process.stderr.write(`❌ ${file} → claimedBy missing: ${claimedBy}
+`);
+  }
+  for (const s of f.staleExempts) {
+    process.stderr.write(`❌ exempt file now meets the floor — promote it: ${s}
+`);
+  }
+  for (const v of f.violations) {
+    process.stderr.write(`❌ ${v.file} ${v.metric}=${v.observed.toFixed(2)}% (need ≥ ${v.required}%)
+`);
+  }
+}
+function reportOrphans(f, args) {
+  if (f.orphans.length === 0)
+    return;
+  process.stderr.write(`${args.strictOrphans ? "❌" : "⚠️ "} ${f.orphans.length} src file(s) no unit test imports
+`);
+  if (args.listOrphans)
+    for (const o of f.orphans)
+      process.stderr.write(`   ${o}
+`);
+  else
+    process.stderr.write(`   --orphans to list, --strict-orphans to fail
+`);
+}
+function reportMutate(report) {
+  if (report.issues.length === 0)
+    return;
+  process.stderr.write(`❌ ${report.issues.length} Stryker target(s) resolve to no files:
+`);
+  for (const i of report.issues) {
+    process.stderr.write(`   ${i.config} [${i.field}] ${i.pattern}
+`);
+  }
+}
+function showHelp() {
+  process.stdout.write(`polly coverage — coverage policy, orphan detection, Stryker target validation
+
+` + `  --strict-orphans   fail on source no unit test imports
+` + `  --orphans          list orphan files
+` + `  --no-mutate        skip the Stryker mutate/testFiles check
+` + `  --config <path>    explicit coverage.config.ts
+` + "  --stdin            read a `bun test --coverage` table from stdin\n");
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    showHelp();
+    return;
+  }
+  const { config, source } = await loadCoverageConfig(args.root, args.configPath);
+  const srcDir = config.srcDir ?? "src";
+  const findings = args.stdin ? await Promise.resolve().then(() => (init_enforce(), exports_enforce)).then(async (m) => {
+    const rows = parseCoverageTable(await readStdin(), srcDir);
+    return m.evaluateCoverage(args.root, rows, config);
+  }) : await enforceCoverage(args.root, config);
+  reportPolicy(findings);
+  reportOrphans(findings, args);
+  let mutate = { configs: [], issues: [] };
+  if (args.mutate) {
+    mutate = await validateMutateTargets(args.root);
+    reportMutate(mutate);
+  }
+  const failed = hasFailure(findings, args.strictOrphans) || mutate.issues.length > 0;
+  if (!failed) {
+    const mode = findings.enforced ? `floor enforced` : "report-only (no defaultThreshold)";
+    const where = source ? "" : " — zero-config";
+    const orphanNote = findings.orphans.length ? `, ${findings.orphans.length} orphan` : "";
+    const mutateNote = mutate.configs.length ? `, ${mutate.configs.length} stryker config(s) ok` : "";
+    process.stdout.write(`✅ coverage ok — ${findings.rowCount} src files, ${mode}${where}${orphanNote}${mutateNote}
+`);
+  }
+  process.exit(failed ? 1 : 0);
+}
+await main();
+
+//# debugId=7B6414401C7DC44464756E2164756E21

package/dist/tools/test/src/coverage-policy/cli.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../tools/test/src/coverage-policy/enforce.ts", "../tools/test/src/coverage-policy/discover.ts", "../tools/test/src/coverage-policy/cli.ts", "../tools/test/src/coverage-policy/mutate-targets.ts"],
+  "sourcesContent": [
+    "/**\n * @fairfox/polly/test/coverage — the coverage-policy engine.\n *\n * Parses a `bun test --coverage` table and applies a {@link CoverageConfig}.\n * It fails on four conditions, not just low numbers: a non-exempt file below\n * the floor, an exempt key whose source no longer exists, an exemption whose\n * `claimedBy` test no longer exists, and an exempt file that has climbed back\n * over the floor (promote it). It also reports orphans — source files no unit\n * test imports, the blind spot a coverage table can't show.\n *\n * Everything here is parameterised by the project root, so the same engine\n * backs Polly's own gate and the consumer-facing `polly coverage` command.\n */\n\nimport { existsSync } from \"node:fs\";\nimport { join, resolve } from \"node:path\";\nimport { Glob } from \"bun\";\nimport type { CoverageConfig } from \"./types\";\n\nexport interface CoverageRow {\n  /** Project-relative, e.g. `src/shared/lib/state.ts`. */\n  file: string;\n  funcs: number;\n  lines: number;\n}\n\nexport interface Violation {\n  file: string;\n  metric: \"lines\" | \"funcs\";\n  observed: number;\n  required: number;\n}\n\nexport interface CoverageFindings {\n  rowCount: number;\n  violations: Violation[];\n  staleExempts: string[];\n  missingExemptFiles: string[];\n  missingClaimedBy: Array<{ file: string; claimedBy: string }>;\n  orphans: string[];\n  /** True when a floor was configured; false means report-only. */\n  enforced: boolean;\n}\n\nconst DEFAULT_SRC = \"src\";\n\n/** `../src/foo.ts` (run from a subdir) → `src/foo.ts` (project-relative). */\nfunction normalizePath(raw: string): string {\n  return raw.replace(/^(?:\\.\\.\\/)+/, \"\");\n}\n\n/**\n * Parse the `bun test --coverage` table. Only rows under `srcDir` are\n * policy-bearing; the `All files` summary and test-infra rows are skipped.\n * Column order is `File | % Funcs | % Lines | Uncovered`.\n */\nexport function parseCoverageTable(text: string, srcDir: string): CoverageRow[] {\n  const prefix = `${srcDir}/`;\n  const rows: CoverageRow[] = [];\n  for (const line of text.split(\"\\n\")) {\n    if (!line.includes(\"|\")) continue;\n    if (line.includes(\"All files\") || line.includes(\"% Funcs\")) continue;\n    if (line.trim().startsWith(\"---\")) continue;\n\n    const cells = line.split(\"|\").map((c) => c.trim());\n    if (cells.length < 3) continue;\n\n    const file = normalizePath(cells[0] ?? \"\");\n    const funcs = Number(cells[1]);\n    const lines = Number(cells[2]);\n    if (!file.startsWith(prefix) || Number.isNaN(funcs) || Number.isNaN(lines)) continue;\n\n    rows.push({ file, funcs, lines });\n  }\n  return rows;\n}\n\n/** Run `bun test --coverage` in the configured cwd and return combined output. */\nexport async function runCoverage(root: string, testCwd: string): Promise<string> {\n  const proc = Bun.spawn([\"bun\", \"test\", \"--coverage\"], {\n    cwd: join(root, testCwd),\n    stdout: \"pipe\",\n    stderr: \"pipe\",\n  });\n  const [out, err] = await Promise.all([\n    new Response(proc.stdout).text(),\n    new Response(proc.stderr).text(),\n  ]);\n  await proc.exited;\n  if (proc.exitCode !== 0) {\n    throw new Error(`bun test --coverage exited ${proc.exitCode}\\n${err}`);\n  }\n  return `${out}\\n${err}`;\n}\n\nfunction evaluateRows(\n  rows: CoverageRow[],\n  config: CoverageConfig\n): { violations: Violation[]; staleExempts: string[] } {\n  const t = config.defaultThreshold;\n  const exempt = config.exempt ?? {};\n  const violations: Violation[] = [];\n  const staleExempts: string[] = [];\n  if (!t) return { violations, staleExempts };\n\n  for (const row of rows) {\n    if (exempt[row.file]) {\n      if (row.lines >= t.lines && row.funcs >= t.funcs) staleExempts.push(row.file);\n      continue;\n    }\n    if (row.lines < t.lines) {\n      violations.push({ file: row.file, metric: \"lines\", observed: row.lines, required: t.lines });\n    }\n    if (row.funcs < t.funcs) {\n      violations.push({ file: row.file, metric: \"funcs\", observed: row.funcs, required: t.funcs });\n    }\n  }\n  return { violations, staleExempts };\n}\n\nfunction validateExemptions(\n  root: string,\n  config: CoverageConfig\n): { missingExemptFiles: string[]; missingClaimedBy: Array<{ file: string; claimedBy: string }> } {\n  const missingExemptFiles: string[] = [];\n  const missingClaimedBy: Array<{ file: string; claimedBy: string }> = [];\n  for (const [file, entry] of Object.entries(config.exempt ?? {})) {\n    if (!existsSync(resolve(root, file))) missingExemptFiles.push(file);\n    const claimedBy = entry.claimedBy.trim();\n    if (!claimedBy.startsWith(\"n/a\") && !existsSync(resolve(root, claimedBy))) {\n      missingClaimedBy.push({ file, claimedBy });\n    }\n  }\n  return { missingExemptFiles, missingClaimedBy };\n}\n\n/** Source files no row covers and no exemption names — the coverage blind spot. */\nasync function findOrphans(\n  root: string,\n  srcDir: string,\n  covered: Set<string>,\n  config: CoverageConfig\n): Promise<string[]> {\n  const exempt = config.exempt ?? {};\n  const orphans: string[] = [];\n  const glob = new Glob(`${srcDir}/**/*.{ts,tsx}`);\n  for await (const file of glob.scan({ cwd: root, onlyFiles: true })) {\n    if (file.endsWith(\".d.ts\") || /\\.test\\.tsx?$/.test(file) || file.includes(\"/__tests__/\")) {\n      continue;\n    }\n    if (covered.has(file) || exempt[file]) continue;\n    orphans.push(file);\n  }\n  return orphans.sort();\n}\n\n/** Apply the policy to a parsed table. Pure — no spawning. */\nexport async function evaluateCoverage(\n  root: string,\n  rows: CoverageRow[],\n  config: CoverageConfig\n): Promise<CoverageFindings> {\n  const srcDir = config.srcDir ?? DEFAULT_SRC;\n  const { violations, staleExempts } = evaluateRows(rows, config);\n  const { missingExemptFiles, missingClaimedBy } = validateExemptions(root, config);\n  const orphans = await findOrphans(root, srcDir, new Set(rows.map((r) => r.file)), config);\n  return {\n    rowCount: rows.length,\n    violations,\n    staleExempts,\n    missingExemptFiles,\n    missingClaimedBy,\n    orphans,\n    enforced: config.defaultThreshold !== undefined,\n  };\n}\n\n/** Run the suite under coverage and apply the policy. */\nexport async function enforceCoverage(\n  root: string,\n  config: CoverageConfig,\n  coverageText?: string\n): Promise<CoverageFindings> {\n  const srcDir = config.srcDir ?? DEFAULT_SRC;\n  const text = coverageText ?? (await runCoverage(root, config.testCwd ?? \".\"));\n  const rows = parseCoverageTable(text, srcDir);\n  return evaluateCoverage(root, rows, config);\n}\n\n/** True when the findings represent a policy failure (orphans are advisory\n *  unless `strictOrphans`). */\nexport function hasFailure(findings: CoverageFindings, strictOrphans: boolean): boolean {\n  return (\n    findings.violations.length > 0 ||\n    findings.staleExempts.length > 0 ||\n    findings.missingExemptFiles.length > 0 ||\n    findings.missingClaimedBy.length > 0 ||\n    (strictOrphans && findings.orphans.length > 0)\n  );\n}\n",
+    "/**\n * @fairfox/polly/test/coverage — zero-config loading.\n *\n * `polly coverage` runs without any config: it looks for a `coverage.config.ts`\n * (or `.js`) at the project root, and if there is none it returns an empty\n * config, which the engine treats as report-only — it prints the numbers and\n * the orphan count but never fails the build. A consumer opts into enforcement\n * by adding a `defaultThreshold`, and into legible tiering by adding `exempt`\n * entries. This mirrors how `polly test --tier` discovers tiers by convention.\n */\n\nimport { existsSync } from \"node:fs\";\nimport { isAbsolute, join, resolve } from \"node:path\";\nimport type { CoverageConfig } from \"./types\";\n\nexport interface LoadedConfig {\n  config: CoverageConfig;\n  /** Absolute path the config was loaded from, or null for the zero-config default. */\n  source: string | null;\n}\n\nfunction isCoverageConfig(value: unknown): value is CoverageConfig {\n  return typeof value === \"object\" && value !== null;\n}\n\nasync function importConfig(path: string): Promise<CoverageConfig> {\n  const mod: Record<string, unknown> = await import(path);\n  const candidate = mod[\"config\"] ?? mod[\"default\"];\n  if (!isCoverageConfig(candidate)) {\n    throw new Error(`${path} must export \\`config\\` (a CoverageConfig object)`);\n  }\n  return candidate;\n}\n\n/**\n * Resolve the coverage config. With `explicitPath` (Polly's own front-end\n * passes scripts/coverage.config.ts) that file must exist. Otherwise look for\n * coverage.config.{ts,js} at the root; absent → the zero-config report-only\n * default.\n */\nexport async function loadCoverageConfig(\n  root: string,\n  explicitPath?: string\n): Promise<LoadedConfig> {\n  if (explicitPath) {\n    const abs = isAbsolute(explicitPath) ? explicitPath : resolve(root, explicitPath);\n    if (!existsSync(abs)) throw new Error(`coverage config not found: ${abs}`);\n    return { config: await importConfig(abs), source: abs };\n  }\n\n  for (const name of [\"coverage.config.ts\", \"coverage.config.js\"]) {\n    const abs = join(root, name);\n    if (existsSync(abs)) return { config: await importConfig(abs), source: abs };\n  }\n  return { config: {}, source: null };\n}\n",
+    "#!/usr/bin/env bun\n\n/**\n * @fairfox/polly/test/coverage — consumer-facing `polly coverage`.\n *\n * Zero-config: run it in any Polly project and it reports per-file coverage,\n * orphan source files, and (if a Stryker config is present) dead mutate/test\n * globs. Add a `coverage.config.ts` with a `defaultThreshold` to turn the\n * report into an enforced gate, and `exempt` entries to record which\n * higher-tier test covers a unit-thin file.\n *\n * Usage:\n *   polly coverage                 # report (zero-config) or enforce (with config)\n *   polly coverage --strict-orphans  # fail on source no unit test imports\n *   polly coverage --orphans         # list the orphan files\n *   polly coverage --no-mutate       # skip the Stryker target check\n *   polly coverage --config <path>   # explicit coverage.config.ts\n *   bun test --coverage | polly coverage --stdin\n */\n\nimport { loadCoverageConfig } from \"./discover\";\nimport { type CoverageFindings, enforceCoverage, hasFailure, parseCoverageTable } from \"./enforce\";\nimport { type MutateTargetReport, validateMutateTargets } from \"./mutate-targets\";\n\ninterface Args {\n  root: string;\n  configPath?: string;\n  strictOrphans: boolean;\n  listOrphans: boolean;\n  stdin: boolean;\n  mutate: boolean;\n  help: boolean;\n}\n\nfunction parseArgs(argv: string[]): Args {\n  const flag = (name: string) => argv.includes(name);\n  const argValue = (name: string): string | undefined => {\n    const i = argv.indexOf(name);\n    return i >= 0 ? argv[i + 1] : undefined;\n  };\n  const strictOrphans = flag(\"--strict-orphans\");\n  return {\n    root: process.cwd(),\n    configPath: argValue(\"--config\"),\n    strictOrphans,\n    listOrphans: strictOrphans || flag(\"--orphans\"),\n    stdin: flag(\"--stdin\"),\n    mutate: !flag(\"--no-mutate\"),\n    help: flag(\"--help\") || flag(\"-h\"),\n  };\n}\n\nasync function readStdin(): Promise<string> {\n  const chunks: string[] = [];\n  for await (const chunk of Bun.stdin.stream()) chunks.push(new TextDecoder().decode(chunk));\n  return chunks.join(\"\");\n}\n\nfunction reportPolicy(f: CoverageFindings): void {\n  for (const m of f.missingExemptFiles) {\n    process.stderr.write(`❌ exempt source missing: ${m}\\n`);\n  }\n  for (const { file, claimedBy } of f.missingClaimedBy) {\n    process.stderr.write(`❌ ${file} → claimedBy missing: ${claimedBy}\\n`);\n  }\n  for (const s of f.staleExempts) {\n    process.stderr.write(`❌ exempt file now meets the floor — promote it: ${s}\\n`);\n  }\n  for (const v of f.violations) {\n    process.stderr.write(\n      `❌ ${v.file} ${v.metric}=${v.observed.toFixed(2)}% (need ≥ ${v.required}%)\\n`\n    );\n  }\n}\n\nfunction reportOrphans(f: CoverageFindings, args: Args): void {\n  if (f.orphans.length === 0) return;\n  process.stderr.write(\n    `${args.strictOrphans ? \"❌\" : \"⚠️ \"} ${f.orphans.length} src file(s) no unit test imports\\n`\n  );\n  if (args.listOrphans) for (const o of f.orphans) process.stderr.write(`   ${o}\\n`);\n  else process.stderr.write(\"   --orphans to list, --strict-orphans to fail\\n\");\n}\n\nfunction reportMutate(report: MutateTargetReport): void {\n  if (report.issues.length === 0) return;\n  process.stderr.write(`❌ ${report.issues.length} Stryker target(s) resolve to no files:\\n`);\n  for (const i of report.issues) {\n    process.stderr.write(`   ${i.config} [${i.field}] ${i.pattern}\\n`);\n  }\n}\n\nfunction showHelp(): void {\n  process.stdout.write(\n    \"polly coverage — coverage policy, orphan detection, Stryker target validation\\n\\n\" +\n      \"  --strict-orphans   fail on source no unit test imports\\n\" +\n      \"  --orphans          list orphan files\\n\" +\n      \"  --no-mutate        skip the Stryker mutate/testFiles check\\n\" +\n      \"  --config <path>    explicit coverage.config.ts\\n\" +\n      \"  --stdin            read a `bun test --coverage` table from stdin\\n\"\n  );\n}\n\nasync function main(): Promise<void> {\n  const args = parseArgs(process.argv.slice(2));\n  if (args.help) {\n    showHelp();\n    return;\n  }\n\n  const { config, source } = await loadCoverageConfig(args.root, args.configPath);\n  const srcDir = config.srcDir ?? \"src\";\n\n  const findings = args.stdin\n    ? await import(\"./enforce\").then(async (m) => {\n        const rows = parseCoverageTable(await readStdin(), srcDir);\n        return m.evaluateCoverage(args.root, rows, config);\n      })\n    : await enforceCoverage(args.root, config);\n\n  reportPolicy(findings);\n  reportOrphans(findings, args);\n\n  let mutate: MutateTargetReport = { configs: [], issues: [] };\n  if (args.mutate) {\n    mutate = await validateMutateTargets(args.root);\n    reportMutate(mutate);\n  }\n\n  const failed = hasFailure(findings, args.strictOrphans) || mutate.issues.length > 0;\n  if (!failed) {\n    const mode = findings.enforced ? `floor enforced` : \"report-only (no defaultThreshold)\";\n    const where = source ? \"\" : \" — zero-config\";\n    const orphanNote = findings.orphans.length ? `, ${findings.orphans.length} orphan` : \"\";\n    const mutateNote = mutate.configs.length\n      ? `, ${mutate.configs.length} stryker config(s) ok`\n      : \"\";\n    process.stdout.write(\n      `✅ coverage ok — ${findings.rowCount} src files, ${mode}${where}${orphanNote}${mutateNote}\\n`\n    );\n  }\n  process.exit(failed ? 1 : 0);\n}\n\nawait main();\n",
+    "/**\n * @fairfox/polly/test/coverage — Stryker mutate-/test-target validation.\n *\n * A Stryker config's `mutate` and `testFiles` lists are hand-curated. A path\n * that is renamed, or a glob whose directory moves, silently resolves to\n * nothing — Stryker mutates fewer files (or none) and the only signal is a\n * long mutation run whose score quietly drops. This asserts, in milliseconds,\n * that every entry still resolves to at least one file.\n *\n * Discovers configs two ways, covering both layouts in the wild: a single\n * `stryker.conf.json` at the root, and a `stryker/` directory of per-package\n * shards.\n */\n\nimport { existsSync, readFileSync } from \"node:fs\";\nimport { join, resolve } from \"node:path\";\nimport { Glob } from \"bun\";\n\ninterface StrykerConfig {\n  mutate?: string[];\n  testFiles?: string[];\n  bun?: { testFiles?: string[] };\n}\n\nexport interface MutateTargetIssue {\n  config: string;\n  field: \"mutate\" | \"testFiles\";\n  pattern: string;\n}\n\nexport interface MutateTargetReport {\n  configs: string[];\n  issues: MutateTargetIssue[];\n}\n\n/** Locate every Stryker config under the project root. */\nexport async function findStrykerConfigs(root: string): Promise<string[]> {\n  const found: string[] = [];\n  const single = join(root, \"stryker.conf.json\");\n  if (existsSync(single)) found.push(single);\n\n  const glob = new Glob(\"stryker/*.{json,conf.json}\");\n  for await (const rel of glob.scan({ cwd: root, onlyFiles: true })) {\n    found.push(join(root, rel));\n  }\n  return found.sort();\n}\n\nfunction isGlob(pattern: string): boolean {\n  return pattern.includes(\"*\") || pattern.includes(\"?\") || pattern.includes(\"[\");\n}\n\nasync function resolvesToFile(pattern: string, cwd: string): Promise<boolean> {\n  if (pattern.startsWith(\"!\")) return true; // negations are filters, not targets\n  if (!isGlob(pattern)) return existsSync(resolve(cwd, pattern));\n  const glob = new Glob(pattern);\n  for await (const _ of glob.scan({ cwd, onlyFiles: true })) return true;\n  return false;\n}\n\nasync function checkField(\n  configPath: string,\n  field: \"mutate\" | \"testFiles\",\n  patterns: string[] | undefined,\n  cwd: string\n): Promise<MutateTargetIssue[]> {\n  const issues: MutateTargetIssue[] = [];\n  for (const pattern of patterns ?? []) {\n    if (!(await resolvesToFile(pattern, cwd))) {\n      issues.push({ config: configPath, field, pattern });\n    }\n  }\n  return issues;\n}\n\n/**\n * Validate every Stryker config under `root`. Paths in a Stryker config are\n * relative to that config's directory; for the monorepo-root configs that is\n * the root, so we resolve globs against `root`.\n */\nexport async function validateMutateTargets(root: string): Promise<MutateTargetReport> {\n  const configs = await findStrykerConfigs(root);\n  const issues: MutateTargetIssue[] = [];\n  for (const configPath of configs) {\n    const config = JSON.parse(readFileSync(configPath, \"utf8\")) as unknown as StrykerConfig;\n    const testFiles = config.testFiles ?? config.bun?.testFiles;\n    issues.push(...(await checkField(configPath, \"mutate\", config.mutate, root)));\n    issues.push(...(await checkField(configPath, \"testFiles\", testFiles, root)));\n  }\n  return { configs, issues };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "7B6414401C7DC44464756E2164756E21",
+  "names": []
+}

package/dist/tools/test/src/coverage-policy/discover.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fairfox/polly/test/coverage — zero-config loading.
+ *
+ * `polly coverage` runs without any config: it looks for a `coverage.config.ts`
+ * (or `.js`) at the project root, and if there is none it returns an empty
+ * config, which the engine treats as report-only — it prints the numbers and
+ * the orphan count but never fails the build. A consumer opts into enforcement
+ * by adding a `defaultThreshold`, and into legible tiering by adding `exempt`
+ * entries. This mirrors how `polly test --tier` discovers tiers by convention.
+ */
+import type { CoverageConfig } from "./types";
+export interface LoadedConfig {
+    config: CoverageConfig;
+    /** Absolute path the config was loaded from, or null for the zero-config default. */
+    source: string | null;
+}
+/**
+ * Resolve the coverage config. With `explicitPath` (Polly's own front-end
+ * passes scripts/coverage.config.ts) that file must exist. Otherwise look for
+ * coverage.config.{ts,js} at the root; absent → the zero-config report-only
+ * default.
+ */
+export declare function loadCoverageConfig(root: string, explicitPath?: string): Promise<LoadedConfig>;

package/dist/tools/test/src/coverage-policy/enforce.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @fairfox/polly/test/coverage — the coverage-policy engine.
+ *
+ * Parses a `bun test --coverage` table and applies a {@link CoverageConfig}.
+ * It fails on four conditions, not just low numbers: a non-exempt file below
+ * the floor, an exempt key whose source no longer exists, an exemption whose
+ * `claimedBy` test no longer exists, and an exempt file that has climbed back
+ * over the floor (promote it). It also reports orphans — source files no unit
+ * test imports, the blind spot a coverage table can't show.
+ *
+ * Everything here is parameterised by the project root, so the same engine
+ * backs Polly's own gate and the consumer-facing `polly coverage` command.
+ */
+import type { CoverageConfig } from "./types";
+export interface CoverageRow {
+    /** Project-relative, e.g. `src/shared/lib/state.ts`. */
+    file: string;
+    funcs: number;
+    lines: number;
+}
+export interface Violation {
+    file: string;
+    metric: "lines" | "funcs";
+    observed: number;
+    required: number;
+}
+export interface CoverageFindings {
+    rowCount: number;
+    violations: Violation[];
+    staleExempts: string[];
+    missingExemptFiles: string[];
+    missingClaimedBy: Array<{
+        file: string;
+        claimedBy: string;
+    }>;
+    orphans: string[];
+    /** True when a floor was configured; false means report-only. */
+    enforced: boolean;
+}
+/**
+ * Parse the `bun test --coverage` table. Only rows under `srcDir` are
+ * policy-bearing; the `All files` summary and test-infra rows are skipped.
+ * Column order is `File | % Funcs | % Lines | Uncovered`.
+ */
+export declare function parseCoverageTable(text: string, srcDir: string): CoverageRow[];
+/** Run `bun test --coverage` in the configured cwd and return combined output. */
+export declare function runCoverage(root: string, testCwd: string): Promise<string>;
+/** Apply the policy to a parsed table. Pure — no spawning. */
+export declare function evaluateCoverage(root: string, rows: CoverageRow[], config: CoverageConfig): Promise<CoverageFindings>;
+/** Run the suite under coverage and apply the policy. */
+export declare function enforceCoverage(root: string, config: CoverageConfig, coverageText?: string): Promise<CoverageFindings>;
+/** True when the findings represent a policy failure (orphans are advisory
+ *  unless `strictOrphans`). */
+export declare function hasFailure(findings: CoverageFindings, strictOrphans: boolean): boolean;

package/dist/tools/test/src/coverage-policy/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fairfox/polly/test/coverage — programmatic API behind `polly coverage`.
+ *
+ * Use the CLI (`polly coverage`) for the common case; import these to script
+ * the policy yourself or to add a coverage tier to a custom runner.
+ */
+export { type LoadedConfig, loadCoverageConfig } from "./discover";
+export { type CoverageFindings, type CoverageRow, enforceCoverage, evaluateCoverage, hasFailure, parseCoverageTable, runCoverage, type Violation, } from "./enforce";
+export { findStrykerConfigs, type MutateTargetIssue, type MutateTargetReport, validateMutateTargets, } from "./mutate-targets";
+export type { CoverageConfig, ExemptEntry, FileThreshold } from "./types";