@avi2dg/checks 0.18.0 → 0.20.0

package/scripts/quality-file.ts

@@ -91,10 +91,33 @@ const EffectSources = Schema.Struct({
   ),
 });
 
+const Library = Schema.Struct({
+  name: Schema.String.check(
+    Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a library name in kebab case" }),
+  ).annotate({ description: "The link checks-vendor manages under repos/" }),
+  package: Schema.NonEmptyString.annotate({ description: "The npm package whose installed version picks the tag" }),
+  repository: Schema.NonEmptyString.annotate({ description: "The git remote checks-vendor clones the tag from" }),
+  tag: Schema.String.check(Schema.isPattern(/\{version\}/, { expected: "a tag template holding {version}" })).annotate({
+    description: "The tag template, with {version} for the installed version",
+  }),
+  path: Schema.optionalKey(
+    FilePath.annotate({ description: "The manifest inside the clone holding the version; package.json when absent" }),
+  ),
+}).annotate({ identifier: "Library" });
+export type Library = typeof Library.Type;
+
 const Sources = Schema.Struct({
   production: Schema.optionalKey(
     Schema.Array(PathGlob).annotate({ description: "The source the repository ships, as against tests and tooling" }),
   ),
+  libraries: Schema.optionalKey(
+    Schema.Array(Library).check(
+      Schema.makeFilter((libraries) => {
+        const repeated = duplicates(libraries.map((library) => library.name));
+        return repeated === undefined || `names ${repeated} more than once`;
+      }),
+    ).annotate({ description: "The libraries checks-vendor pins to a shared read-only clone" }),
+  ),
   effect: Schema.optionalKey(EffectSources),
 });
 
@@ -124,11 +147,15 @@ function nests(outer: string, inner: string): boolean {
   return outer === inner || inner.startsWith(`${outer}/`);
 }
 
+function duplicates(names: readonly string[]): string | undefined {
+  const repeated = names.filter((name, index) => names.indexOf(name) !== index);
+  return repeated.length === 0 ? undefined : [...new Set(repeated)].join(", ");
+}
+
 const Features = Schema.Array(Feature).check(
   Schema.makeFilter((features) => {
-    const names = features.map((feature) => feature.name);
-    const repeated = names.filter((name, index) => names.indexOf(name) !== index);
-    if (repeated.length > 0) return `names ${[...new Set(repeated)].join(", ")} more than once`;
+    const repeated = duplicates(features.map((feature) => feature.name));
+    if (repeated !== undefined) return `names ${repeated} more than once`;
     for (const outer of features) {
       const inner = features.find((other) => other !== outer && nests(outer.root, other.root));
       if (inner !== undefined) return `gives ${inner.root} to both ${outer.name} and ${inner.name}`;

package/scripts/quality.ts

@@ -38,6 +38,7 @@ export type GeneratedWorkflow = {
 export type WorkflowRecipe = {
   readonly commitlintConfig: string;
   readonly bunVersionFile: boolean;
+  readonly nodeVersionFile: boolean;
 };
 
 class NativeConfigUnreadable extends Schema.TaggedError<NativeConfigUnreadable>()("NativeConfigUnreadable", {
@@ -109,7 +110,9 @@ function runScalar(command: string): string {
 }
 
 export function commitlintWorkflow(commitlintConfig: string): string {
-  return `on:
+  return `permissions:
+  contents: read
+on:
   pull_request:
     types: [opened, edited, synchronize, reopened]
 jobs:
@@ -123,16 +126,24 @@ jobs:
       - run: printf '%s' "$PR_TITLE (#0000)" > "$RUNNER_TEMP/pr-title"
         env:
           PR_TITLE: \${{ github.event.pull_request.title }}
+      # A title starting with git's comment character lints as empty without this: commentChar moves off '#'.
       - run: ${titleLint(commitlintConfig)}
+        env:
+          GIT_CONFIG_COUNT: "1"
+          GIT_CONFIG_KEY_0: core.commentChar
+          GIT_CONFIG_VALUE_0: "\\x01"
 `;
 }
 
-export function suiteWorkflow(defaultBranch: string, gates: readonly string[], bunVersionFile: boolean): string {
+export function suiteWorkflow(defaultBranch: string, gates: readonly string[], bunVersionFile: boolean, nodeVersionFile: boolean): string {
+  const node = nodeVersionFile
+    ? "      - uses: actions/setup-node@v5\n        with:\n          node-version-file: .node-version\n"
+    : "";
   const setup = bunVersionFile
     ? "      - uses: oven-sh/setup-bun@v2\n        with:\n          bun-version-file: .bun-version\n"
     : "      - uses: oven-sh/setup-bun@v2\n";
   const steps = gates.map((gate) => `      - run: ${runScalar(gate)}\n`).join("");
-  return `name: ci\non:\n  push:\n    branches: [${defaultBranch}]\n  pull_request:\n    types: [opened, edited, synchronize, reopened]\njobs:\n  checks:\n    runs-on: ubuntu-latest\n    steps:\n      # The head, not GitHub's merge ref, so the tree the gates read is the commit the range ends at.\n      # The whole history, since the range starts where the head branched from the base branch.\n      - uses: actions/checkout@v5\n        with:\n          ref: \${{ github.event.pull_request.head.sha || github.sha }}\n          fetch-depth: 0\n${setup}      - run: bun install --frozen-lockfile\n${steps}`;
+  return `name: ci\non:\n  push:\n    branches: [${defaultBranch}]\n  pull_request:\n    types: [opened, edited, synchronize, reopened]\njobs:\n  checks:\n    runs-on: ubuntu-latest\n    steps:\n      # The head, not GitHub's merge ref, so the tree the gates read is the commit the range ends at.\n      # The whole history, since the range starts where the head branched from the base branch.\n      - uses: actions/checkout@v5\n        with:\n          ref: \${{ github.event.pull_request.head.sha || github.sha }}\n          fetch-depth: 0\n${node}${setup}      - run: bun install --frozen-lockfile\n${steps}`;
 }
 
 export function workflowsFor(quality: Quality, recipe: WorkflowRecipe): readonly GeneratedWorkflow[] {
@@ -143,7 +154,10 @@ export function workflowsFor(quality: Quality, recipe: WorkflowRecipe): readonly
   if (quality.gates?.ci === undefined) return [commitlint];
   const suite = quality.gates.ci.filter((gate) => !runsInTitleLint(gate, recipe.commitlintConfig));
   return [
-    { file: SUITE_WORKFLOW, content: suiteWorkflow(quality.defaultBranch ?? DEFAULT_BRANCH, suite, recipe.bunVersionFile) },
+    {
+      file: SUITE_WORKFLOW,
+      content: suiteWorkflow(quality.defaultBranch ?? DEFAULT_BRANCH, suite, recipe.bunVersionFile, recipe.nodeVersionFile),
+    },
     commitlint,
   ];
 }
@@ -247,6 +261,7 @@ const recipeOf = Effect.fn("recipeOf")(function* (root: string) {
     // The kit never installs itself, so its own tree lints with its root config.
     commitlintConfig: (yield* isKit(root)) ? OWN_COMMITLINT_CONFIG : KIT_COMMITLINT_CONFIG,
     bunVersionFile: yield* fs.exists(path.join(root, ".bun-version")),
+    nodeVersionFile: yield* fs.exists(path.join(root, ".node-version")),
   } satisfies WorkflowRecipe;
 });
 

package/scripts/quarantine-clock.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+import { Console, Effect, Schema } from "effect";
+import { commitOf, git, isShallowBoundary, refArgs } from "./git.ts";
+import { runMain } from "./main.ts";
+import { TEST_FILE } from "./test-layout.ts";
+
+export const QUARANTINE = "tests/quarantine/";
+export const QUARANTINE_DAYS = 30;
+const DAY_SECONDS = 86400;
+
+export class QuarantineError extends Schema.TaggedError<QuarantineError>()("QuarantineError", {
+  message: Schema.String,
+}) {}
+
+const USAGE = "usage: quarantine-clock.ts <ref> | <base-ref> <head-ref>";
+
+export type Entry =
+  | { readonly kind: "entered"; readonly sha: string; readonly at: number; readonly day: string }
+  | { readonly kind: "truncated" };
+
+export type Overdue = {
+  readonly file: string;
+  readonly day: string;
+  readonly days: number;
+};
+
+export type ClockResult = {
+  readonly checked: number;
+  readonly overdue: readonly Overdue[];
+};
+
+const HEADER = /^commit ([0-9a-f]{40}|[0-9a-f]{64}) (\d+) (\S+)$/;
+const TWO_PATHS = /^[RC]/;
+
+type Status = readonly [status: string, from: string, to: string];
+
+type CommitBlock = {
+  readonly sha: string;
+  readonly at: number;
+  readonly day: string;
+  readonly statuses: readonly Status[];
+};
+
+function parseBlocks(output: string): readonly CommitBlock[] {
+  const blocks: { readonly sha: string; readonly at: number; readonly day: string; readonly statuses: Status[] }[] = [];
+  const fields = output.split("\0");
+  let index = 0;
+  while (index < fields.length) {
+    const field = (fields[index] ?? "").replace(/^\n/, "");
+    index += 1;
+    const header = HEADER.exec(field);
+    if (header !== null) {
+      blocks.push({ sha: header[1] ?? "", at: Number(header[2] ?? "0"), day: (header[3] ?? "").slice(0, "YYYY-MM-DD".length), statuses: [] });
+      continue;
+    }
+    if (field === "") continue;
+    const paths = TWO_PATHS.test(field) ? 2 : 1;
+    blocks.at(-1)?.statuses.push([field, fields[index] ?? "", fields[index + paths - 1] ?? ""]);
+    index += paths;
+  }
+  return blocks;
+}
+
+function entryIn({ sha, at, day, statuses }: CommitBlock, path: string): Entry | undefined {
+  const entered = statuses.some(
+    ([status, from, to]) =>
+      to === path && (status === "A" || status.startsWith("C") || (status.startsWith("R") && !from.startsWith(QUARANTINE))),
+  );
+  return entered ? { kind: "entered", sha, at, day } : undefined;
+}
+
+function followedPath({ statuses }: CommitBlock, path: string): string {
+  const rename = statuses.find(([status, , to]) => status.startsWith("R") && to === path);
+  return rename?.[1] ?? path;
+}
+
+export function findEntry(output: string, file: string): Entry {
+  let current = file;
+  for (const block of parseBlocks(output)) {
+    const entry = entryIn(block, current);
+    if (entry !== undefined) return entry;
+    current = followedPath(block, current);
+  }
+  return { kind: "truncated" };
+}
+
+export function overdueOf(
+  entries: readonly { readonly file: string; readonly at: number; readonly day: string }[],
+  headAt: number,
+): readonly Overdue[] {
+  const limit = QUARANTINE_DAYS * DAY_SECONDS;
+  return entries
+    .flatMap((entry) =>
+      headAt - entry.at > limit
+        ? [{ file: entry.file, day: entry.day, days: Math.floor((headAt - entry.at) / DAY_SECONDS) }]
+        : [],
+    )
+    .toSorted((a, b) => (a.file < b.file ? -1 : 1));
+}
+
+export function report({ checked, overdue }: ClockResult): string {
+  if (overdue.length === 0) {
+    return `quarantine-clock: no test in ${QUARANTINE} is past ${QUARANTINE_DAYS} days (${checked} checked)`;
+  }
+  const verb = overdue.length === 1 ? "is" : "are";
+  return [
+    `quarantine-clock: ${overdue.length} test(s) in ${QUARANTINE} ${verb} past ${QUARANTINE_DAYS} days; fix each and move it back, or delete it:`,
+    ...overdue.map((file) => `  ${file.file} entered quarantine on ${file.day} (${file.days} days ago)`),
+  ].join("\n");
+}
+
+const filesAt = Effect.fn("filesAt")(function* (root: string, head: string) {
+  const listed = yield* git(["ls-tree", "-r", "-z", "--name-only", head, "--", QUARANTINE], root);
+  return listed.split("\0").filter((file) => TEST_FILE.test(file));
+});
+
+const entryAt = Effect.fn("entryAt")(function* (root: string, head: string, file: string) {
+  const output = yield* git(["log", "--follow", "--root", "--name-status", "-z", "--format=commit %H %at %aI", head, "--", file], root);
+  const entry = findEntry(output, file);
+  if (entry.kind === "truncated" || (yield* isShallowBoundary(entry.sha, root))) {
+    return yield* new QuarantineError({
+      message: `cannot see ${file} entering ${QUARANTINE}; fetch the whole history, since a shallow clone ends before it`,
+    });
+  }
+  return { file, at: entry.at, day: entry.day };
+});
+
+const headAt = Effect.fn("headAt")(function* (root: string, head: string) {
+  const shown = yield* git(["show", "-s", "--format=%at %ct", head], root);
+  const dates = shown.trim().split(" ").map(Number);
+  if (dates.length !== 2 || !dates.every(Number.isInteger)) {
+    return yield* new QuarantineError({ message: `cannot read when ${head} was written` });
+  }
+  return Math.max(...dates);
+});
+
+export const runHead = Effect.fn("runHead")(function* (root: string, head: string) {
+  const files = yield* filesAt(root, head);
+  const entries = yield* Effect.forEach(files, (file) => entryAt(root, head, file));
+  return { checked: files.length, overdue: overdueOf(entries, yield* headAt(root, head)) } satisfies ClockResult;
+});
+
+const clock = Effect.gen(function* () {
+  const { first, second } = yield* refArgs(process.argv.slice(2), USAGE);
+  if (second !== undefined) yield* commitOf(first);
+  const head = yield* commitOf(second ?? first);
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const result = yield* runHead(root, head);
+  yield* Console.log(report(result));
+  return result.overdue.length === 0;
+});
+
+if (import.meta.main) runMain("quarantine-clock", clock);

package/scripts/repetition.ts

@@ -4,22 +4,22 @@ import { changedPaths, checkoutFiles, collect, git, pathsAt, rangeFromArgs } fro
 import { runMain } from "./main.ts";
 import { readQuality } from "./quality-file.ts";
 
-type Fragment = {
+export type Fragment = {
   readonly file: string;
   readonly start: number;
   readonly end: number;
 };
 
-type Clone = readonly [Fragment, Fragment];
+export type Clone = readonly [Fragment, Fragment];
 
-type Rise = {
+export type Rise = {
   readonly file: string;
   readonly before: number;
   readonly after: number;
   readonly clones: readonly Clone[];
 };
 
-type Held = {
+export type Held = {
   readonly measured: number;
   readonly rises: readonly Rise[];
   readonly advisory: ReadonlyMap<string, number>;
@@ -86,7 +86,7 @@ const scan = Effect.fn("scan")(
   Effect.scoped,
 );
 
-function clonesOf(file: string, clones: readonly Clone[]): readonly Clone[] {
+export function clonesOf(file: string, clones: readonly Clone[]): readonly Clone[] {
   return clones
     .flatMap(([first, second]): Clone[] => {
       if (first.file === file) return [[first, second]];
@@ -95,6 +95,36 @@ function clonesOf(file: string, clones: readonly Clone[]): readonly Clone[] {
     .toSorted(([a], [b]) => a.start - b.start);
 }
 
+// Decides which held file repeats more lines than the same path, or the path it was renamed
+// from, repeated at the base.
+export function risesOf(
+  held: readonly string[],
+  before: ReadonlyMap<string, number>,
+  after: ReadonlyMap<string, number>,
+  formerPath: ReadonlyMap<string, string>,
+  clones: readonly Clone[],
+): readonly Rise[] {
+  return held
+    .flatMap((file): Rise[] => {
+      const was = before.get(formerPath.get(file) ?? file) ?? 0;
+      const is = after.get(file) ?? 0;
+      return is > was ? [{ file, before: was, after: is, clones: clonesOf(file, clones) }] : [];
+    })
+    .toSorted((a, b) => a.file.localeCompare(b.file));
+}
+
+// Tallies every held file that did not rise, plus every file outside the held set, as advisory.
+export function heldOf(
+  measured: number,
+  rises: readonly Rise[],
+  after: ReadonlyMap<string, number>,
+  othersRepeated: ReadonlyMap<string, number>,
+): Held {
+  const risen = new Set(rises.map((rise) => rise.file));
+  const advisory = [...after].filter(([file]) => !risen.has(file)).concat([...othersRepeated]);
+  return { measured, rises, advisory: new Map(advisory.toSorted(([a], [b]) => a.localeCompare(b))) };
+}
+
 const runHold = Effect.fn("runHold")(function* (root: string, production: readonly string[], base: string, head: string) {
   const pathspecs = [...production.map((glob) => `:(glob)${glob}`), DECLARATIONS];
   const held = yield* pathsAt(head, pathspecs, root);
@@ -107,28 +137,19 @@ const runHold = Effect.fn("runHold")(function* (root: string, production: readon
   const before = repeatedLines(yield* scan(root, base, yield* pathsAt(base, pathspecs, root)));
   const clones = yield* scan(root, head, held);
   const after = repeatedLines(clones);
-  const rises = held.flatMap((file): Rise[] => {
-    const was = before.get(formerPath.get(file) ?? file) ?? 0;
-    const is = after.get(file) ?? 0;
-    return is > was ? [{ file, before: was, after: is, clones: clonesOf(file, clones) }] : [];
-  });
-  const risen = new Set(rises.map((rise) => rise.file));
-  const advisory = [...after].filter(([file]) => !risen.has(file)).concat([...repeatedLines(yield* scan(root, head, others))]);
-  return {
-    measured: held.length,
-    rises: rises.toSorted((a, b) => a.file.localeCompare(b.file)),
-    advisory: new Map(advisory.toSorted(([a], [b]) => a.localeCompare(b))),
-  } satisfies Held;
+  const rises = risesOf(held, before, after, formerPath, clones);
+  const othersRepeated = repeatedLines(yield* scan(root, head, others));
+  return heldOf(held.length, rises, after, othersRepeated) satisfies Held;
 });
 
-function describe({ file, before, after, clones }: Rise): readonly string[] {
+export function describe({ file, before, after, clones }: Rise): readonly string[] {
   return [
     `  ${file}: ${after} repeated line(s), up from ${before}`,
     ...clones.map(([own, other]) => `    ${own.file}:${own.start}-${own.end} repeats ${other.file}:${other.start}-${other.end}`),
   ];
 }
 
-function report({ measured, rises, advisory }: Held): string {
+export function report({ measured, rises, advisory }: Held): string {
   const verdict =
     rises.length === 0
       ? [`${NAME}: ${measured} production file(s) repeat no more lines than where the range starts, ${MEASURE}`]

package/scripts/size-budget.ts

@@ -20,9 +20,9 @@ import {
   type SizeRule,
 } from "./size-rules.ts";
 
-type Held = { readonly path: string; readonly from: string };
+export type Held = { readonly path: string; readonly from: string };
 
-type Site = {
+export type Site = {
   readonly file: string;
   readonly line: number | undefined;
   readonly rule: SizeRule["rule"];
@@ -30,7 +30,7 @@ type Site = {
   readonly message: string;
 };
 
-type Growth = {
+export type Growth = {
   readonly file: string;
   readonly rule: SizeRule["rule"];
   readonly base: number;
@@ -38,7 +38,7 @@ type Growth = {
   readonly sites: readonly Site[];
 };
 
-type Verdict =
+export type Verdict =
   | { readonly applies: "all"; readonly held: number; readonly overruns: readonly Site[]; readonly advisory: readonly Site[] }
   | { readonly applies: "ratchet"; readonly held: number; readonly growths: readonly Growth[]; readonly advisory: readonly Site[] };
 
@@ -69,7 +69,17 @@ const Diagnostic = Schema.Struct({
 
 const decodeReport = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ diagnostics: Schema.Array(Diagnostic) })));
 
-function rulesOf(budget: Budget): Record<string, unknown> {
+type Rules = Readonly<Record<string, unknown>>;
+
+export type SizeConfig = {
+  readonly plugins: readonly string[];
+  readonly jsPlugins: readonly string[];
+  readonly categories: Readonly<Record<string, string>>;
+  readonly rules: Rules;
+  readonly overrides: readonly { readonly files: readonly string[]; readonly rules: Rules }[];
+};
+
+function rulesOf(budget: Budget): Rules {
   return Object.fromEntries(
     SIZE_RULES.map((entry) => {
       const max = budget[entry.key];
@@ -78,7 +88,7 @@ function rulesOf(budget: Budget): Record<string, unknown> {
   );
 }
 
-function sizeConfig({ production, tests }: Budgets, plugin: string): unknown {
+export function sizeConfig({ production, tests }: Budgets, plugin: string): SizeConfig {
   return {
     plugins: [],
     jsPlugins: [plugin],
@@ -88,7 +98,7 @@ function sizeConfig({ production, tests }: Budgets, plugin: string): unknown {
   };
 }
 
-function heldByChange(changes: readonly Change[]): readonly Held[] {
+export function heldByChange(changes: readonly Change[]): readonly Held[] {
   return changes.flatMap((change) => {
     if (change.kind === "written") return [{ path: change.path, from: change.path }];
     if (change.kind === "renamed" && change.edited) return [{ path: change.path, from: change.from }];
@@ -118,7 +128,9 @@ const materializeBase = Effect.fn("materializeBase")(function* (root: string, ba
   yield* git(["checkout-index", "--all", `--prefix=${tree}/`], root, { env });
 });
 
-const siteOf = (budgets: Budgets) =>
+export const siteOf = (
+  budgets: Budgets,
+): ((diagnostic: typeof Diagnostic.Type) => Effect.Effect<readonly Site[], OxlintUnreadable>) =>
   Effect.fn("siteOf")(function* ({ code, message, filename, labels }: typeof Diagnostic.Type) {
     const rule = SIZE_RULES.find((candidate) => code === diagnosticCode(candidate));
     if (rule === undefined) return [];
@@ -166,7 +178,8 @@ function total(sites: readonly Site[]): number {
   return sites.reduce((sum, { overrun }) => sum + overrun, 0);
 }
 
-function growthsOf(head: readonly Site[], base: readonly Site[]): readonly Growth[] {
+// Sums each rule per file separately, so a shrink in one rule or file never offsets a growth in another.
+export function growthsOf(head: readonly Site[], base: readonly Site[]): readonly Growth[] {
   const before = byFileAndRule(base);
   return [...byFileAndRule(head).entries()].flatMap(([group, sites]) => {
     const [first] = sites;
@@ -175,6 +188,24 @@ function growthsOf(head: readonly Site[], base: readonly Site[]): readonly Growt
   });
 }
 
+// Decides the verdict from sites oxlint already measured: which are held to the range or the
+// whole tree, and, under ratchet, which grew past what the base measured for the same file and rule.
+export function verdictOf(
+  applies: Applies,
+  held: number,
+  holds: ReadonlySet<string>,
+  sites: readonly Site[],
+  baseSites: readonly Site[],
+): Verdict {
+  const heldSites = sites.filter((site) => holds.has(site.file));
+  if (applies !== "ratchet") {
+    return { applies, held, overruns: heldSites, advisory: sites.filter((site) => !holds.has(site.file)) };
+  }
+  const growths = growthsOf(heldSites, baseSites);
+  const failing = new Set(growths.flatMap((growth) => growth.sites));
+  return { applies, held, growths, advisory: sites.filter((site) => !failing.has(site)) };
+}
+
 const heldFiles = Effect.fn("heldFiles")(function* (root: string, applies: Applies, pathspecs: readonly string[], base: string, head: string) {
   if (applies === "all") return (yield* pathsAt(head, pathspecs, root)).map((path): Held => ({ path, from: path }));
   return heldByChange(yield* changedPaths(base, head, pathspecs, root));
@@ -196,25 +227,20 @@ const runBudget = Effect.fn("runBudget")(
     if (held.length + others.length > 0) yield* materializeHead(root, head, [...holds, ...others], headTree);
     const plugin = path.join(import.meta.dir, "..", "dist", "index.js");
     const sites = yield* measure(headTree, budgets, plugin);
-    const heldSites = sites.filter((site) => holds.has(site.file));
-    if (applies !== "ratchet") {
-      return { applies, held: held.length, overruns: heldSites, advisory: sites.filter((site) => !holds.has(site.file)) } satisfies Verdict;
-    }
+    if (applies !== "ratchet") return verdictOf(applies, held.length, holds, sites, []);
 
     const baseTree = path.join(scratch, "base");
     if (held.length > 0) yield* materializeBase(root, base, held, baseTree);
-    const growths = growthsOf(heldSites, yield* measure(baseTree, budgets, plugin));
-    const failing = new Set(growths.flatMap((growth) => growth.sites));
-    return { applies, held: held.length, growths, advisory: sites.filter((site) => !failing.has(site)) } satisfies Verdict;
+    return verdictOf(applies, held.length, holds, sites, yield* measure(baseTree, budgets, plugin));
   },
   Effect.scoped,
 );
 
-function describe({ file, line, message }: Site, indent = "  "): string {
+export function describe({ file, line, message }: Site, indent = "  "): string {
   return `${indent}${file}${line === undefined ? "" : `:${line}`}: ${message}`;
 }
 
-function verdictLines(verdict: Verdict): readonly string[] {
+export function verdictLines(verdict: Verdict): readonly string[] {
   const scope = SCOPE[verdict.applies];
   if (verdict.applies === "ratchet") {
     if (verdict.growths.length === 0) return [`${NAME}: ${verdict.held} file(s), ${scope}, raise no overrun past the base`];
@@ -230,7 +256,7 @@ function verdictLines(verdict: Verdict): readonly string[] {
   return [`${NAME}: ${verdict.overruns.length} overrun(s) of the budget in ${scope}:`, ...verdict.overruns.map((site) => describe(site))];
 }
 
-function report(verdict: Verdict): string {
+export function report(verdict: Verdict): string {
   const { advisory } = verdict;
   const notice =
     advisory.length === 0
@@ -239,7 +265,7 @@ function report(verdict: Verdict): string {
   return [...verdictLines(verdict), ...notice].join("\n");
 }
 
-function passes(verdict: Verdict): boolean {
+export function passes(verdict: Verdict): boolean {
   return verdict.applies === "ratchet" ? verdict.growths.length === 0 : verdict.overruns.length === 0;
 }