@avi2dg/checks 0.21.0 → 0.23.0

package/scripts/quality.ts

@@ -1,363 +0,0 @@
-#!/usr/bin/env bun
-import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import kitOxlint from "../oxlintrc.json" with { type: "json" };
-import kitManifest from "../package.json" with { type: "json" };
-import effectLanguageService from "../presets/effect.language-service.json" with { type: "json" };
-import effectOxlint from "../presets/effect.oxlint.json" with { type: "json" };
-import { git } from "./git.ts";
-import { DEFAULT_BRANCH } from "./gates.ts";
-import { runMain, Usage } from "./main.ts";
-import { QualityUnreadable, readQuality, renderJson, type Quality } from "./quality-file.ts";
-import { invokes, plainCommand } from "./shell-command.ts";
-
-// oxlint resolves an override's files, and the language service an override's include, against the
-// directory of the config that holds it, so a fragment anywhere but the root matches nothing there.
-export const OXLINT_FRAGMENT = "oxlintrc.quality.json";
-export const TSCONFIG_FRAGMENT = "tsconfig.quality.json";
-export const SUITE_WORKFLOW = ".github/workflows/ci.yml";
-export const COMMITLINT_WORKFLOW = ".github/workflows/commitlint.yml";
-
-const NAME = "checks-quality";
-const USAGE = `usage: ${NAME} --check | generate`;
-const GENERATE = `${NAME} generate`;
-
-type EffectSources = NonNullable<NonNullable<Quality["sources"]>["effect"]>;
-
-export type Fragment = {
-  readonly file: typeof OXLINT_FRAGMENT | typeof TSCONFIG_FRAGMENT;
-  readonly extendedBy: string;
-  readonly reader: string;
-  readonly content: unknown;
-};
-
-export type GeneratedWorkflow = {
-  readonly file: typeof SUITE_WORKFLOW | typeof COMMITLINT_WORKFLOW;
-  readonly content: string;
-};
-
-export type WorkflowRecipe = {
-  readonly commitlintConfig: string;
-  readonly bunVersionFile: boolean;
-  readonly nodeVersionFile: boolean;
-};
-
-class NativeConfigUnreadable extends Schema.TaggedError<NativeConfigUnreadable>()("NativeConfigUnreadable", {
-  message: Schema.String,
-}) {}
-
-function oxlintFragment({ paths, exempt = [] }: EffectSources): unknown {
-  const override = {
-    files: paths,
-    ...(exempt.length === 0 ? {} : { excludeFiles: exempt }),
-    // An override that leaves out any of the kit's plugins turns on the category rules of the ones it adds.
-    plugins: [...kitOxlint.plugins, ...effectOxlint.plugins.filter((plugin) => !kitOxlint.plugins.includes(plugin))],
-    rules: effectOxlint.rules,
-  };
-  return {
-    $schema: "./node_modules/oxlint/configuration_schema.json",
-    // A config without plugins brings oxlint's default plugins into the one extending it.
-    plugins: kitOxlint.plugins,
-    overrides: [override],
-  };
-}
-
-function tsconfigFragment({ paths, exempt = [] }: EffectSources): unknown {
-  const override = { include: paths, ...(exempt.length === 0 ? {} : { exclude: exempt }), options: effectLanguageService };
-  return { compilerOptions: { plugins: [{ name: "@effect/language-service", overrides: [override] }] } };
-}
-
-const FRAGMENTS = [
-  {
-    file: OXLINT_FRAGMENT,
-    extendedBy: ".oxlintrc.json",
-    reader: "oxlint",
-    kitConfig: "./node_modules/@avi2dg/checks/oxlintrc.json",
-    kitRepositoryConfig: "./oxlintrc.json",
-    kitConfigReason: "so the kit's oxlint rules are not loaded",
-    build: oxlintFragment,
-  },
-  {
-    file: TSCONFIG_FRAGMENT,
-    extendedBy: "tsconfig.json",
-    reader: "the language service",
-    kitConfig: "@avi2dg/checks/tsconfig.effect.json",
-    kitRepositoryConfig: "./tsconfig.effect.json",
-    kitConfigReason: "the one accepted spelling of the kit's Effect config",
-    build: tsconfigFragment,
-  },
-] as const;
-
-export function fragmentsFor(quality: Quality): readonly Fragment[] {
-  const effect = quality.sources?.effect;
-  if (effect === undefined) return [];
-  return FRAGMENTS.map(({ file, extendedBy, reader, build }) => ({ file, extendedBy, reader, content: build(effect) }));
-}
-
-const OWN_COMMITLINT_CONFIG = "./commitlint.config.js";
-const KIT_COMMITLINT_CONFIG = "./node_modules/@avi2dg/checks/commitlint.config.js";
-
-function titleLint(commitlintConfig: string): string {
-  return `./node_modules/.bin/commitlint --config ${commitlintConfig} --edit "$RUNNER_TEMP/pr-title"`;
-}
-
-function runsInTitleLint(gate: string, commitlintConfig: string): boolean {
-  const words = plainCommand(gate);
-  return words !== undefined && invokes(plainCommand(titleLint(commitlintConfig)), words);
-}
-
-// YAML 1.2's core schema resolves these plain scalars to a null, a boolean or a number, and YAML 1.1 parsers also read yes, no, on and off as booleans.
-const NON_STRING_SCALAR =
-  /^(?:~|null|Null|NULL|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)(?:[eE][-+]?[0-9]+)?|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/;
-
-function runScalar(command: string): string {
-  return /(^[\s#&*!|>@`'"%{[-])|:\s|\s#|:$|[\n\\]/.test(command) || NON_STRING_SCALAR.test(command)
-    ? JSON.stringify(command)
-    : command;
-}
-
-function flowScalar(label: string): string {
-  return /[,[\]{}]/.test(label) ? JSON.stringify(label) : runScalar(label);
-}
-
-function runsOnLine(runsOn: Quality["runsOn"]): string {
-  if (runsOn === undefined) return "ubuntu-latest";
-  return `[${runsOn.map(flowScalar).join(", ")}]`;
-}
-
-export function commitlintWorkflow(commitlintConfig: string, runsOn: Quality["runsOn"]): string {
-  return `permissions:
-  contents: read
-on:
-  pull_request:
-    types: [opened, edited, synchronize, reopened]
-jobs:
-  commitlint:
-    runs-on: ${runsOnLine(runsOn)}
-    steps:
-      - uses: actions/checkout@v5
-      - uses: oven-sh/setup-bun@v2
-      - run: bun install --frozen-lockfile
-      # Only the title is linted: it is what a squash merge lands, with GitHub appending " (#N)" to it.
-      - 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,
-  nodeVersionFile: boolean,
-  runsOn: Quality["runsOn"],
-): 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: ${runsOnLine(runsOn)}\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[] {
-  const commitlint: GeneratedWorkflow = {
-    file: COMMITLINT_WORKFLOW,
-    content: commitlintWorkflow(recipe.commitlintConfig, quality.runsOn),
-  };
-  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, recipe.nodeVersionFile, quality.runsOn),
-    },
-    commitlint,
-  ];
-}
-
-const NativeConfig = Schema.Struct({
-  extends: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(Schema.String)])),
-});
-const decodeNativeConfig = Schema.decodeUnknownEffect(NativeConfig);
-
-const parseJsonc = (text: string, file: string) =>
-  Effect.try({
-    try: (): unknown => Bun.JSONC.parse(text),
-    catch: (error) => new NativeConfigUnreadable({ message: `cannot parse ${file}: ${String(error)}` }),
-  });
-
-const extendsOf = Effect.fn("extendsOf")(function* (root: string, file: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const target = path.join(root, file);
-  if (!(yield* fs.exists(target))) return [];
-  const config = yield* fs.readFileString(target).pipe(
-    Effect.flatMap((text) => parseJsonc(text, file)),
-    Effect.flatMap(decodeNativeConfig),
-    Effect.mapError((cause) => new NativeConfigUnreadable({ message: `cannot read extends from ${file}: ${cause.message}` })),
-  );
-  const listed = config.extends ?? [];
-  return (typeof listed === "string" ? [listed] : listed).map((entry) => path.normalize(entry));
-});
-
-const decodeJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
-
-const sameJson = (text: string, content: unknown): Effect.Effect<boolean> =>
-  decodeJson(text).pipe(
-    Effect.map((parsed) => Bun.deepEquals(parsed, content, true)),
-    Effect.orElseSucceed(() => false),
-  );
-
-const decodePackageName = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ name: Schema.optionalKey(Schema.String) })));
-
-const isKit = Effect.fn("isKit")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const manifest = (yield* Path.Path).join(root, "package.json");
-  if (!(yield* fs.exists(manifest))) return false;
-  const { name } = yield* decodePackageName(yield* fs.readFileString(manifest)).pipe(
-    Effect.mapError((cause) => new QualityUnreadable({ message: `package.json: ${cause.message}` })),
-  );
-  return name === kitManifest.name;
-});
-
-const fragmentProblems = Effect.fn("fragmentProblems")(function* (root: string, source: string, expected: readonly Fragment[]) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const problems: string[] = [];
-  const kitRepository = yield* isKit(root);
-  for (const { file, extendedBy, reader, kitConfig, kitRepositoryConfig, kitConfigReason } of FRAGMENTS) {
-    const target = path.join(root, file);
-    const fragment = expected.find((candidate) => candidate.file === file);
-    const present = yield* fs.exists(target);
-    if (fragment === undefined) {
-      if (present) problems.push(`${file} is left over, since no sources.effect is declared; run ${GENERATE}`);
-      continue;
-    }
-    if (!present) {
-      problems.push(`${file} is missing; run ${GENERATE}`);
-    } else if (!(yield* sameJson(yield* fs.readFileString(target), fragment.content))) {
-      problems.push(`${file} is stale against ${source} and the kit's presets; run ${GENERATE}`);
-    }
-    const configured = yield* extendsOf(root, extendedBy);
-    if (!configured.includes(file)) {
-      problems.push(`${extendedBy} does not extend ./${file}, so ${reader} never reads it`);
-    }
-    const requiredKitConfig = kitRepository ? kitRepositoryConfig : kitConfig;
-    if (!configured.includes(path.normalize(requiredKitConfig))) {
-      problems.push(`${extendedBy} does not extend ${requiredKitConfig}, ${kitConfigReason}`);
-    }
-  }
-  return problems;
-});
-
-const unmatchedPaths = Effect.fn("unmatchedPaths")(function* (root: string, quality: Quality) {
-  const declared = [
-    ...(quality.sources?.production ?? []).map((glob) => ({
-      glob,
-      key: "sources.production",
-      holds: "no source to checks-size-budget or checks-repetition",
-    })),
-    ...(quality.sources?.effect?.paths ?? []).map((glob) => ({ glob, key: "sources.effect.paths", holds: "nothing to the Effect rules" })),
-  ];
-  const problems: string[] = [];
-  for (const { glob, key, holds } of declared) {
-    const matched = yield* git(["ls-files", "--cached", "--others", "--exclude-standard", "--", `:(glob)${glob}`], root);
-    if (matched.trim() === "") problems.push(`${key} ${glob} matches no file, so it holds ${holds}`);
-  }
-  return problems;
-});
-
-const recipeOf = Effect.fn("recipeOf")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  return {
-    // 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;
-});
-
-const workflowProblems = Effect.fn("workflowProblems")(function* (
-  root: string,
-  source: string,
-  expected: readonly GeneratedWorkflow[],
-) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const problems: string[] = [];
-  for (const { file, content } of expected) {
-    const target = path.join(root, file);
-    if (!(yield* fs.exists(target))) {
-      problems.push(`${file} is missing; run ${GENERATE}`);
-    } else if ((yield* fs.readFileString(target)) !== content) {
-      problems.push(`${file} is stale against ${source} and the kit recipe; run ${GENERATE}`);
-    }
-  }
-  return problems;
-});
-
-const check = Effect.fn("check")(function* (root: string) {
-  const { source, quality } = yield* readQuality(root);
-  const expected = fragmentsFor(quality);
-  const workflows = workflowsFor(quality, yield* recipeOf(root));
-  const problems = [
-    ...(yield* fragmentProblems(root, source, expected)),
-    ...(yield* workflowProblems(root, source, workflows)),
-    ...(yield* unmatchedPaths(root, quality)),
-  ];
-  if (problems.length > 0) {
-    yield* Console.error([`${NAME}: ${problems.length} problem(s) with what ${source} declares:`, ...problems.map((line) => `  ${line}`)].join("\n"));
-    return false;
-  }
-  const held = [...expected.map((fragment) => fragment.file), ...workflows.map((workflow) => workflow.file)];
-  const verb = held.length === 1 ? "holds" : "hold";
-  yield* Console.log(
-    expected.length === 0
-      ? `${NAME}: no sources.effect is declared, so no fragment is generated; ${held.join(" and ")} ${verb} the kit recipe`
-      : `${NAME}: ${held.join(" and ")} ${verb} what ${source} declares`,
-  );
-  return true;
-});
-
-const generate = Effect.fn("generate")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const { quality } = yield* readQuality(root);
-  const expected = fragmentsFor(quality);
-  for (const { file } of FRAGMENTS) {
-    const target = path.join(root, file);
-    const fragment = expected.find((candidate) => candidate.file === file);
-    if (fragment !== undefined) {
-      yield* fs.writeFileString(target, renderJson(fragment.content));
-      yield* Console.log(`${NAME}: wrote ${file}`);
-    } else if (yield* fs.exists(target)) {
-      yield* fs.remove(target);
-      yield* Console.log(`${NAME}: removed ${file}`);
-    }
-  }
-  const workflows = workflowsFor(quality, yield* recipeOf(root));
-  yield* fs.makeDirectory(path.join(root, ".github", "workflows"), { recursive: true });
-  for (const { file, content } of workflows) {
-    yield* fs.writeFileString(path.join(root, file), content);
-    yield* Console.log(`${NAME}: wrote ${file}`);
-  }
-  return yield* check(root);
-});
-
-const main = Effect.gen(function* () {
-  const [mode, ...extra] = process.argv.slice(2);
-  if (extra.length > 0 || (mode !== "--check" && mode !== "generate")) return yield* new Usage({ message: USAGE });
-  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  return mode === "generate" ? yield* generate(root) : yield* check(root);
-});
-
-if (import.meta.main) runMain(NAME, main);

package/scripts/size-budget.ts

@@ -1,285 +0,0 @@
-#!/usr/bin/env bun
-import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import { changedPaths, collect, git, pathsAt, rangeEnds, type Change } from "./git.ts";
-import { runMain } from "./main.ts";
-import { renderJson } from "./quality-file.ts";
-import { rangeGateInputs } from "./range-gate.ts";
-import {
-  budgetOf,
-  budgetsOf,
-  diagnosticCode,
-  qualifiedName,
-  SIZE_DEFAULTS,
-  SIZE_RULES,
-  TESTS_DIRECTORY,
-  type Applies,
-  type Budget,
-  type Budgets,
-  type LimitKey,
-  type Size,
-  type SizeRule,
-} from "./size-rules.ts";
-
-export type Held = { readonly path: string; readonly from: string };
-
-export type Site = {
-  readonly file: string;
-  readonly line: number | undefined;
-  readonly rule: SizeRule["rule"];
-  readonly overrun: number;
-  readonly message: string;
-};
-
-export type Growth = {
-  readonly file: string;
-  readonly rule: SizeRule["rule"];
-  readonly base: number;
-  readonly head: number;
-  readonly sites: readonly Site[];
-};
-
-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[] };
-
-class OxlintUnreadable extends Schema.TaggedError<OxlintUnreadable>()("OxlintUnreadable", {
-  message: Schema.String,
-}) {}
-
-const NAME = "size-budget";
-const USAGE = "usage: size-budget.ts <ref> | <base-ref> <head-ref>";
-const DECLARATIONS = ":(exclude,glob)**/*.d.ts";
-const TYPESCRIPT = [":(glob)**/*.ts", ":(glob)**/*.tsx", DECLARATIONS];
-const TESTS = [`:(glob)${TESTS_DIRECTORY}/**/*.ts`, `:(glob)${TESTS_DIRECTORY}/**/*.tsx`];
-const CONFIG = ".size-budget.oxlintrc.json";
-const WHOLE_FILE: LimitKey = "fileLines";
-const OXLINT_FOUND_NOTHING = 0;
-const OXLINT_FOUND_ERRORS = 1;
-const SCOPE = {
-  ratchet: "the production and test files the range adds or changes",
-  all: "every production and test file",
-} satisfies Record<Applies, string>;
-
-const Diagnostic = Schema.Struct({
-  code: Schema.String,
-  message: Schema.String,
-  filename: Schema.String,
-  labels: Schema.Array(Schema.Struct({ span: Schema.Struct({ line: Schema.Int }) })),
-});
-
-const decodeReport = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ diagnostics: Schema.Array(Diagnostic) })));
-
-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];
-      return [qualifiedName(entry), max === undefined ? "off" : ["error", { max, ...entry.options }]];
-    }),
-  );
-}
-
-export function sizeConfig({ production, tests }: Budgets, plugin: string): SizeConfig {
-  return {
-    plugins: [],
-    jsPlugins: [plugin],
-    categories: { correctness: "off" },
-    rules: rulesOf(production),
-    overrides: [{ files: [`${TESTS_DIRECTORY}/**`], rules: rulesOf(tests) }],
-  };
-}
-
-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 }];
-    return [];
-  });
-}
-
-// oxlint reads files from disk, and the working tree need not hold the head: a merge checkout or an uncommitted edit.
-const materializeHead = Effect.fn("materializeHead")(function* (root: string, head: string, files: readonly string[], tree: string) {
-  const env = { GIT_INDEX_FILE: `${tree}.index` };
-  yield* git(["read-tree", head], root, { env });
-  yield* git(["checkout-index", "-z", "--stdin", `--prefix=${tree}/`], root, { env, input: files.map((file) => `${file}\0`).join("") });
-});
-
-// Each file is written at its head path, so a rename is measured against the budget it is held to now.
-const materializeBase = Effect.fn("materializeBase")(function* (root: string, base: string, held: readonly Held[], tree: string) {
-  const env = { GIT_INDEX_FILE: `${tree}.index` };
-  const found = (yield* git(["cat-file", "--batch-check=%(objecttype) %(objectname)"], root, {
-    input: held.map(({ from }) => `${base}:${from}\n`).join(""),
-  })).split("\n");
-  const entries = held.flatMap(({ path }, index) => {
-    const [type, blob] = (found[index] ?? "").split(" ");
-    return type === "blob" ? [`100644 ${blob}\t${path}\0`] : [];
-  });
-  if (entries.length === 0) return;
-  yield* git(["update-index", "-z", "--index-info"], root, { env, input: entries.join("") });
-  yield* git(["checkout-index", "--all", `--prefix=${tree}/`], root, { env });
-});
-
-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 [];
-    const measured = rule.measured.exec(message)?.[1];
-    const max = budgetOf(budgets, filename)[rule.key];
-    if (measured === undefined || max === undefined) {
-      return yield* new OxlintUnreadable({ message: `cannot read ${rule.rule} for ${filename} from oxlint: ${message}` });
-    }
-    const wholeFile = rule.key === WHOLE_FILE;
-    return [
-      {
-        file: filename,
-        line: wholeFile ? undefined : labels[0]?.span.line,
-        rule: rule.rule,
-        overrun: Number(measured) - max,
-        message: wholeFile ? `${message} Maximum allowed is ${max}.` : message,
-      } satisfies Site,
-    ];
-  });
-
-const measure = Effect.fn("measure")(function* (tree: string, budgets: Budgets, plugin: string) {
-  const fs = yield* FileSystem.FileSystem;
-  if (!(yield* fs.exists(tree))) return [];
-  // oxlint reads an override's glob from the directory of the config that holds it, so the config sits in the tree.
-  yield* fs.writeFileString((yield* Path.Path).join(tree, CONFIG), renderJson(sizeConfig(budgets, plugin)));
-
-  const { stdout, stderr, exitCode } = yield* collect("oxlint", ["-c", CONFIG, "-f", "json", "."], tree).pipe(
-    Effect.mapError((cause) => new OxlintUnreadable({ message: `cannot run oxlint: ${cause.message}` })),
-  );
-  if (exitCode !== OXLINT_FOUND_NOTHING && exitCode !== OXLINT_FOUND_ERRORS) {
-    return yield* new OxlintUnreadable({ message: `oxlint exited ${exitCode}: ${stderr.trim() || stdout.trim()}` });
-  }
-  const { diagnostics } = yield* decodeReport(stdout).pipe(
-    Effect.mapError((cause) => new OxlintUnreadable({ message: `cannot read oxlint's report: ${cause.message}` })),
-  );
-  const sites = (yield* Effect.forEach(diagnostics, siteOf(budgets))).flat();
-  return sites.toSorted((a, b) => a.file.localeCompare(b.file) || (a.line ?? 0) - (b.line ?? 0));
-});
-
-function byFileAndRule(sites: readonly Site[]): ReadonlyMap<string, readonly Site[]> {
-  return Map.groupBy(sites, ({ file, rule }) => `${file}\0${rule}`);
-}
-
-function total(sites: readonly Site[]): number {
-  return sites.reduce((sum, { overrun }) => sum + overrun, 0);
-}
-
-// 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;
-    const growth = { base: total(before.get(group) ?? []), head: total(sites), sites };
-    return first !== undefined && growth.head > growth.base ? [{ file: first.file, rule: first.rule, ...growth }] : [];
-  });
-}
-
-// 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));
-});
-
-const runBudget = Effect.fn("runBudget")(
-  function* (root: string, size: Size, production: readonly string[], base: string, head: string) {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const applies = size.applies ?? SIZE_DEFAULTS.applies;
-    const budgets = budgetsOf(size);
-    const pathspecs = [...production.map((glob) => `:(glob)${glob}`), ...TESTS, DECLARATIONS];
-    const held = yield* heldFiles(root, applies, pathspecs, base, head);
-    const holds = new Set(held.map((file) => file.path));
-    const others = (yield* pathsAt(head, TYPESCRIPT, root)).filter((file) => !holds.has(file));
-    const scratch = yield* fs.makeTempDirectoryScoped({ prefix: "checks-size-budget-" });
-
-    const headTree = path.join(scratch, "head");
-    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);
-    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);
-    return verdictOf(applies, held.length, holds, sites, yield* measure(baseTree, budgets, plugin));
-  },
-  Effect.scoped,
-);
-
-export function describe({ file, line, message }: Site, indent = "  "): string {
-  return `${indent}${file}${line === undefined ? "" : `:${line}`}: ${message}`;
-}
-
-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`];
-    return [
-      `${NAME}: ${verdict.growths.length} overrun(s) grew past the base in ${scope}:`,
-      ...verdict.growths.flatMap(({ file, rule, base, head, sites }) => [
-        `  ${file}: ${rule} over by ${head} in total, up from ${base}`,
-        ...sites.map((site) => describe(site, "    ")),
-      ]),
-    ];
-  }
-  if (verdict.overruns.length === 0) return [`${NAME}: ${verdict.held} file(s), ${scope}, keep within the budget`];
-  return [`${NAME}: ${verdict.overruns.length} overrun(s) of the budget in ${scope}:`, ...verdict.overruns.map((site) => describe(site))];
-}
-
-export function report(verdict: Verdict): string {
-  const { advisory } = verdict;
-  const notice =
-    advisory.length === 0
-      ? []
-      : [`${NAME}: advisory, ${advisory.length} overrun(s) where the budget does not hold yet:`, ...advisory.map((site) => describe(site))];
-  return [...verdictLines(verdict), ...notice].join("\n");
-}
-
-export function passes(verdict: Verdict): boolean {
-  return verdict.applies === "ratchet" ? verdict.growths.length === 0 : verdict.overruns.length === 0;
-}
-
-const budget = Effect.gen(function* () {
-  const { refs, root, source, quality } = yield* rangeGateInputs(USAGE);
-  if (quality.size === undefined) {
-    yield* Console.log(`${NAME}: ${source} declares no size budget`);
-    return true;
-  }
-  const { base, head } = yield* rangeEnds(refs.first, refs.second, root);
-  const verdict = yield* runBudget(root, quality.size, quality.sources?.production ?? [], base, head);
-
-  yield* Console.log(report(verdict));
-  return passes(verdict);
-});
-
-if (import.meta.main) runMain(NAME, budget);