@avi2dg/checks 0.43.0 → 0.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avi2dg/checks",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "description": "Deterministic checks shared across a set of TypeScript repositories",
   "license": "MIT",
   "repository": {
@@ -17,13 +17,14 @@
     "docs/design.md",
     "docs/gates/",
     "bunfig.toml",
-    "commitlint.config.js",
+    "commitlint.config.ts",
     "dependency-cruiser.config.js",
     "knip-base.json",
     "src/quality/lint-coverage.sh",
     "src/core/main.ts",
     "src/core/git.ts",
     "src/core/gates.ts",
+    "src/core/declared-inputs.ts",
     "src/core/lint.ts",
     "src/delivery/changelog.ts",
     "src/delivery/changelog-write.ts",
@@ -39,13 +40,14 @@
     "src/core/swc.ts",
     "src/testing/test-report.ts",
     "src/testing/flake.ts",
+    "src/testing/flake-preload.ts",
     "src/delivery/commit-identity.ts",
     "src/delivery/commit-title.ts",
     "src/delivery/docs-only.ts",
     "src/testing/mutation.ts",
-    "src/testing/mutation-scope.js",
-    "src/testing/mutation-guard-plugin.js",
+    "src/testing/mutation-refusal.ts",
     "src/testing/mutation-compare.ts",
+    "src/testing/mutation-scope.ts",
     "src/testing/mutation-baseline.ts",
     "src/testing/mutation-baseline-saved.ts",
     "src/testing/subsumed-tests.ts",
@@ -71,6 +73,9 @@
     "src/testing/quarantine-clock.ts",
     "src/docs/sentence-length.ts",
     "src/docs/docs.ts",
+    "src/docs/copy.ts",
+    "src/docs/copy-text.ts",
+    "src/docs/copy-html.ts",
     "src/dependencies/vendor.ts",
     "src/dependencies/vendor-args.ts",
     "src/dependencies/cache-root.ts",
@@ -89,6 +94,7 @@
     "src/quality/presets/effect.language-service.json",
     "src/quality/presets/oxlint.ts",
     "src/quality/presets/dependency-cruiser.ts",
+    "src/quality/presets/stylelint.ts",
     "src/quality/effect-scope.ts",
     "src/quality/jsonc-patch.ts",
     "src/dependencies/imports.ts",
@@ -100,6 +106,7 @@
     "dist/effect-channel/index.js",
     "dist/readability/index.js",
     "dist/data-shape/index.js",
+    "dist/mutation/",
     "dist/presets/"
   ],
   "exports": {
@@ -123,6 +130,10 @@
     "./dependency-cruiser": {
       "types": "./dist/presets/dependency-cruiser.d.ts",
       "default": "./dist/presets/dependency-cruiser.js"
+    },
+    "./stylelint": {
+      "types": "./dist/presets/stylelint.d.ts",
+      "default": "./dist/presets/stylelint.js"
     }
   },
   "bin": {
@@ -142,6 +153,7 @@
     "checks-mutation": "src/testing/mutation.ts",
     "checks-mutation-compare": "src/testing/mutation-compare.ts",
     "checks-mutation-baseline": "src/testing/mutation-baseline.ts",
+    "checks-mutation-scope": "src/testing/mutation-scope.ts",
     "checks-subsumed-tests": "src/testing/subsumed-tests.ts",
     "checks-ci-wiring": "src/delivery/ci-wiring.ts",
     "checks-comment-gate": "src/quality/comment-gate.ts",
@@ -151,20 +163,24 @@
     "checks-exports": "src/complexity/exports.ts",
     "checks-quarantine-clock": "src/testing/quarantine-clock.ts",
     "checks-docs": "src/docs/docs.ts",
+    "checks-copy": "src/docs/copy.ts",
     "checks-vendor": "src/dependencies/vendor.ts",
     "checks-advisories": "src/dependencies/advisories.ts",
     "checks-secrets": "src/delivery/secrets.ts",
     "checks-frontend-syntax": "src/quality/frontend-syntax.ts",
+    "checks-no-plain-js": "src/quality/no-plain-js.ts",
     "checks-browser": "src/quality/browser/browser.ts",
     "checks-imports": "src/dependencies/imports.ts",
     "checks-effect-scope": "src/quality/effect-scope.ts"
   },
   "scripts": {
     "prepare": "bun src/dependencies/vendor.ts --library effect --package effect --repository https://github.com/Effect-TS/effect.git --tag 'effect@{version}' --path packages/effect/package.json",
-    "build": "bun build src/quality/effect-channel/index.ts --outdir dist/effect-channel --target node --format esm && bun build src/complexity/readability/index.ts --outdir dist/readability --target node --format esm && bun build src/quality/data-shape/index.ts --outdir dist/data-shape --target node --format esm && bun build src/quality/presets/oxlint.ts src/quality/presets/knip.ts src/quality/presets/dependency-cruiser.ts --outdir dist/presets --target node --format esm && tsc -p tsconfig.presets.json && bun scripts/configs-write.ts && bun src/quality/effect-scope.ts && bun scripts/doc-templates-write.ts && bun src/delivery/changelog-write.ts && bun scripts/doc-blocks-write.ts",
+    "build": "bun build src/quality/effect-channel/index.ts --outdir dist/effect-channel --target node --format esm && bun build src/complexity/readability/index.ts --outdir dist/readability --target node --format esm && bun build src/quality/data-shape/index.ts --outdir dist/data-shape --target node --format esm && bun build src/testing/mutation-guard-plugin.ts src/testing/mutation-refusal.ts --outdir dist/mutation --target node --format esm && bun build src/quality/presets/oxlint.ts src/quality/presets/knip.ts src/quality/presets/dependency-cruiser.ts src/quality/presets/stylelint.ts --outdir dist/presets --target node --format esm && tsc -p tsconfig.presets.json && bun scripts/configs-write.ts && bun src/quality/effect-scope.ts && bun scripts/doc-templates-write.ts && bun src/delivery/changelog-write.ts && bun scripts/doc-blocks-write.ts",
     "lint": "oxlint && bun src/core/lint.ts",
     "typecheck": "tsc --noEmit && effect-tsgo diagnostics --project tsconfig.json --format text --strict",
     "test": "bun src/testing/test.ts",
+    "test:unit": "bun src/testing/test.ts --tier=unit",
+    "test:e2e": "bun src/testing/test.ts --tier=e2e --parallel=4",
     "mutate": "bunx stryker run",
     "mutate:incremental": "bunx stryker run --incremental"
   },
@@ -181,6 +197,8 @@
     "playwright-core": "1.63.0",
     "postcss-html": "2.0.0",
     "stylelint": "17.16.0",
+    "stylelint-config-standard": "40.0.0",
+    "stylelint-plugin-use-baseline": "1.4.7",
     "typescript": "7.0.2"
   },
   "peerDependenciesMeta": {
@@ -198,6 +216,12 @@
     },
     "stylelint": {
       "optional": true
+    },
+    "stylelint-config-standard": {
+      "optional": true
+    },
+    "stylelint-plugin-use-baseline": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -218,6 +242,8 @@
     "playwright-core": "1.63.0",
     "postcss-html": "2.0.0",
     "stylelint": "17.16.0",
+    "stylelint-config-standard": "40.0.0",
+    "stylelint-plugin-use-baseline": "1.4.7",
     "typescript": "7.0.2"
   },
   "dependencies": {
@@ -227,7 +253,8 @@
     "@effect/platform-node-shared": "4.0.0",
     "@total-typescript/ts-reset": "0.6.1",
     "commonmark": "0.31.2",
-    "knip": "6.38.0"
+    "knip": "6.38.0",
+    "minimatch": "10.2.6"
   },
   "overrides": {
     "qs": "6.16.0",

package/src/complexity/suppressions-ratchet.ts

@@ -3,13 +3,15 @@ import { Console, Effect, Schema } from "effect";
 import { git, commitOf, parentOrEmptyTree, refArgs } from "../core/git.ts";
 import { runMain } from "../core/main.ts";
 
-export const SUPPRESSIONS = "oxlint-suppressions.json";
+export const SUPPRESSIONS = ["oxlint-suppressions.json", "stylelint-suppressions.json"] as const;
+
+export type SuppressionsFile = (typeof SUPPRESSIONS)[number];
 
 export type Suppressions = ReadonlyMap<string, ReadonlyMap<string, number>>;
 
-export type Rise =
-  | { readonly kind: "rose"; readonly file: string; readonly rule: string; readonly base: number; readonly head: number }
-  | { readonly kind: "appeared"; readonly file: string; readonly rule: string; readonly head: number };
+type Place = { readonly list: SuppressionsFile; readonly file: string; readonly rule: string };
+
+export type Rise = Place & ({ readonly kind: "rose"; readonly base: number; readonly head: number } | { readonly kind: "appeared"; readonly head: number });
 
 export type Ratchet = {
   readonly counted: number;
@@ -49,40 +51,44 @@ export const parseSuppressions = Effect.fn("parseSuppressions")(function* (
   return suppressions;
 });
 
-type Count = {
-  readonly file: string;
-  readonly rule: string;
-  readonly count: number;
-};
+type Count = Place & { readonly count: number };
 
-function countsOf(suppressions: Suppressions): readonly Count[] {
-  return [...suppressions].flatMap(([file, rules]) => [...rules].map(([rule, count]) => ({ file, rule, count })));
+function countsOf(list: SuppressionsFile, suppressions: Suppressions): readonly Count[] {
+  return [...suppressions].flatMap(([file, rules]) => [...rules].map(([rule, count]) => ({ list, file, rule, count })));
 }
 
-function riseOf({ file, rule, count }: Count, before: number | undefined): readonly Rise[] {
-  if (before === undefined) return count > 0 ? [{ kind: "appeared", file, rule, head: count }] : [];
-  return count > before ? [{ kind: "rose", file, rule, base: before, head: count }] : [];
+function riseOf({ count, ...place }: Count, before: number | undefined): readonly Rise[] {
+  if (before === undefined) return count > 0 ? [{ ...place, kind: "appeared", head: count }] : [];
+  return count > before ? [{ ...place, kind: "rose", base: before, head: count }] : [];
 }
 
-export function compareSuppressions(base: Suppressions, head: Suppressions): Ratchet {
-  const counts = countsOf(head);
+export function compareSuppressions(list: SuppressionsFile, base: Suppressions, head: Suppressions): Ratchet {
+  const counts = countsOf(list, head);
   const rises = counts.flatMap((counted) => riseOf(counted, base.get(counted.file)?.get(counted.rule)));
-  const lowered = countsOf(base).filter(({ file, rule, count }) => (head.get(file)?.get(rule) ?? 0) < count).length;
+  const lowered = countsOf(list, base).filter(({ file, rule, count }) => (head.get(file)?.get(rule) ?? 0) < count).length;
   rises.sort((a, b) => a.file.localeCompare(b.file) || a.rule.localeCompare(b.rule));
   return { counted: counts.length, lowered, rises };
 }
 
+export function combined(ratchets: readonly Ratchet[]): Ratchet {
+  return {
+    counted: ratchets.reduce((sum, { counted }) => sum + counted, 0),
+    lowered: ratchets.reduce((sum, { lowered }) => sum + lowered, 0),
+    rises: ratchets.flatMap(({ rises }) => rises),
+  };
+}
+
 function describeRise(rise: Rise): string {
   const change = rise.kind === "rose" ? `rose from ${rise.base} to ${rise.head}` : `appeared with ${rise.head}`;
-  return `${rise.file} ${rise.rule} ${change}`;
+  return `${rise.list} ${rise.file} ${rise.rule} ${change}`;
 }
 
 export function report({ counted, lowered, rises }: Ratchet): string {
   if (rises.length === 0) {
-    return `suppressions-ratchet: no count in ${SUPPRESSIONS} rose or appeared (${counted} at the head, ${lowered} lowered)`;
+    return `suppressions-ratchet: no count in ${SUPPRESSIONS.join(" or ")} rose or appeared (${counted} at the head, ${lowered} lowered)`;
   }
   return [
-    `suppressions-ratchet: ${rises.length} count(s) in ${SUPPRESSIONS} rose or appeared; fix the site instead of suppressing it:`,
+    `suppressions-ratchet: ${rises.length} count(s) rose or appeared; fix the site instead of suppressing it:`,
     ...rises.map((rise) => `  ${describeRise(rise)}`),
   ].join("\n");
 }
@@ -94,22 +100,28 @@ const mergeBase = Effect.fn("mergeBase")(function* (base: string, head: string)
   return commit.trim();
 });
 
-const suppressionsAt = Effect.fn("suppressionsAt")(function* (treeish: string) {
-  const blob = (yield* git(["ls-tree", "--object-only", treeish, "--", SUPPRESSIONS])).trim();
+const suppressionsAt = Effect.fn("suppressionsAt")(function* (list: SuppressionsFile, treeish: string) {
+  const blob = (yield* git(["ls-tree", "--object-only", treeish, "--", list])).trim();
   if (blob === "") return new Map() satisfies Suppressions;
-  return yield* parseSuppressions(yield* git(["cat-file", "blob", blob]), `${SUPPRESSIONS} at ${treeish}`);
+  return yield* parseSuppressions(yield* git(["cat-file", "blob", blob]), `${list} at ${treeish}`);
+});
+
+const compareAt = Effect.fn("compareAt")(function* (base: string, head: string) {
+  const ratchets: Ratchet[] = [];
+  for (const list of SUPPRESSIONS) ratchets.push(compareSuppressions(list, yield* suppressionsAt(list, base), yield* suppressionsAt(list, head)));
+  return combined(ratchets);
 });
 
 export const runRange = Effect.fn("runRange")(function* (base: string, head: string) {
   const headCommit = yield* commitOf(head);
   // At the base tip, a count the base branch lowered after the head branched off would read as a rise at the head.
   const branchPoint = yield* mergeBase(yield* commitOf(base), headCommit);
-  return compareSuppressions(yield* suppressionsAt(branchPoint), yield* suppressionsAt(headCommit));
+  return yield* compareAt(branchPoint, headCommit);
 });
 
 export const runTip = Effect.fn("runTip")(function* (tip: string) {
   const tipCommit = yield* commitOf(tip);
-  return compareSuppressions(yield* suppressionsAt(yield* parentOrEmptyTree(tipCommit)), yield* suppressionsAt(tipCommit));
+  return yield* compareAt(yield* parentOrEmptyTree(tipCommit), tipCommit);
 });
 
 const ratchet = Effect.gen(function* () {

package/src/core/declared-inputs.ts

@@ -0,0 +1,77 @@
+import type { BunServices } from "@effect/platform-bun";
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { runMain, Usage } from "./main.ts";
+
+export type Declared = {
+  readonly name: string;
+  readonly file: string;
+  readonly declares: string;
+};
+
+export type Input = {
+  readonly glob: string;
+  readonly files: readonly string[];
+};
+
+export type Violation = {
+  readonly file: string;
+  readonly line: number;
+  readonly column: number;
+  readonly text: string;
+};
+
+export type Verdict<S> = {
+  readonly report: (scan: S) => string;
+  readonly passes: (scan: S) => boolean;
+};
+
+const Declaration = Schema.Struct({ inputs: Schema.NonEmptyArray(Schema.NonEmptyString) });
+
+const decodeDeclaration = Schema.decodeUnknownEffect(Schema.fromJsonString(Declaration));
+
+const readInputs = Effect.fn("readInputs")(function* (root: string, { file, declares }: Declared) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = (yield* Path.Path).join(root, file);
+  if (!(yield* fs.exists(path))) {
+    return yield* new Usage({ message: `${file} is missing, and a repository opts in to this gate by declaring its ${declares} there` });
+  }
+  const { inputs } = yield* decodeDeclaration(yield* fs.readFileString(path)).pipe(
+    Effect.mapError(({ message }) => new Usage({ message: `${file} does not decode: ${message}` })),
+  );
+  return inputs;
+});
+
+export function emptyInputs(inputs: readonly Input[]): readonly Input[] {
+  return inputs.filter(({ files }) => files.length === 0);
+}
+
+export function violationLine({ file, line, column, text }: Violation): string {
+  return `${file}:${line}:${column} ${text}`;
+}
+
+export function inputsReport(name: string, inputs: readonly Input[], problems: readonly string[]): string {
+  const files = new Set(inputs.flatMap((input) => input.files)).size;
+  const scanned = `${files} file(s) from ${inputs.length} declared input(s)`;
+  if (problems.length === 0) return `${name}: no violation in ${scanned}`;
+  return [`${name}: ${problems.length} problem(s) in ${scanned}:`, ...problems.map((problem) => `  ${problem}`)].join("\n");
+}
+
+export const declaredGate = Effect.fn("declaredGate")(function* <S, E>(
+  declared: Declared,
+  scanInputs: (root: string, globs: readonly string[]) => Effect.Effect<S, E, BunServices.BunServices>,
+  { report, passes }: Verdict<S>,
+  directory: string | undefined,
+) {
+  const root = (yield* Path.Path).resolve(directory ?? ".");
+  const scan = yield* scanInputs(root, yield* readInputs(root, declared));
+  yield* Console.log(report(scan));
+  return passes(scan);
+});
+
+export function runDeclaredGate<S, E extends { readonly message: string }>(
+  declared: Declared,
+  scanInputs: (root: string, globs: readonly string[]) => Effect.Effect<S, E, BunServices.BunServices>,
+  verdict: Verdict<S>,
+): void {
+  runMain(declared.name, declaredGate(declared, scanInputs, verdict, process.argv[2]));
+}

package/src/core/gates.ts

@@ -40,6 +40,8 @@ const OXLINT_CONFIG: TrackedContent = { pathspecs: ["oxlint.config.ts"], content
 
 const FRONTEND_SYNTAX_DECLARATION: TrackedContent = { pathspecs: ["frontend-syntax.json"], content: "a frontend syntax declaration" };
 
+const COPY_DECLARATION: TrackedContent = { pathspecs: ["copy.json"], content: "a copy declaration" };
+
 export const KIT_GATES = [
   { bin: "checks-lint-coverage", vector: "quality", file: "lint-coverage.sh", reads: "tree", appliesTo: LINTED_SOURCE },
   { bin: "checks-test-layout", vector: "testing", file: "test-layout.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
@@ -47,10 +49,12 @@ export const KIT_GATES = [
   { bin: "checks-comment-gate", vector: "quality", file: "comment-gate.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-effect-scope", vector: "quality", file: "effect-scope.ts", reads: "tree", args: ["--check"], appliesTo: OXLINT_CONFIG },
   { bin: "checks-frontend-syntax", vector: "quality", file: "frontend-syntax.ts", reads: "tree", appliesTo: FRONTEND_SYNTAX_DECLARATION },
+  { bin: "checks-no-plain-js", vector: "quality", file: "no-plain-js.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-suppressions-ratchet", vector: "complexity", file: "suppressions-ratchet.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-ci-wiring", vector: "delivery", file: "ci-wiring.ts", reads: "tree", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-secrets", vector: "delivery", file: "secrets.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-docs", vector: "docs", file: "docs.ts", reads: "range", alsoReads: "every agent file at the head commit", appliesTo: EVERY_REPOSITORY },
+  { bin: "checks-copy", vector: "docs", file: "copy.ts", reads: "tree", appliesTo: COPY_DECLARATION },
   { bin: "checks-repetition", vector: "complexity", file: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-unused", vector: "complexity", file: "unused.ts", reads: "tree", appliesTo: LINTED_SOURCE },
   { bin: "checks-exports", vector: "complexity", file: "exports.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },

package/src/core/git.ts

@@ -29,6 +29,15 @@ export const collect = Effect.fn("collect")(
   Effect.scoped,
 );
 
+export const workingTreeFiles = Effect.fn("workingTreeFiles")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const listed = yield* git(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], root);
+  return yield* Effect.filter(listed.split("\0").filter(Boolean), (file) => fs.exists(path.join(root, file)), {
+    concurrency: "unbounded",
+  });
+});
+
 export const git = Effect.fn("git")(function* (args: readonly string[], cwd?: string, feed?: Feed) {
   const failed = (reason: string): GitFailure => new GitFailure({ message: `git ${args.join(" ")}: ${reason.trim()}` });
   const { stdout, stderr, exitCode } = yield* collect("git", args, cwd, feed).pipe(

package/src/delivery/ci-wiring.ts

@@ -17,6 +17,7 @@ export type Gate = {
   readonly command: string;
   readonly words: Command;
   readonly alternatives: readonly Command[];
+  readonly partition: readonly Command[];
 };
 
 export type Declaration = {
@@ -63,6 +64,8 @@ export class WiringError extends Schema.TaggedError<WiringError>()("WiringError"
 
 const WORKFLOWS = ".github/workflows";
 const SCRIPTED = ["lint", "build", "typecheck", "test"];
+const WHOLE_SUITE = "bun run test";
+const SPLIT_SUITE = ["test:unit", "test:e2e"];
 const BUILT_TREE = "git diff --exit-code";
 const TITLE_LINT = "bunx checks-commit-title";
 // The gate holds until every consumer migrates, so the direct commitlint call still counts.
@@ -196,6 +199,21 @@ function entryPointCommand(gate: Command, lintGates: readonly KitGate[]): Comman
   return index === -1 ? undefined : [...gate.slice(0, index), ENTRY_POINT.bin];
 }
 
+type Invocation = Omit<RunStep, "script">;
+
+function invocations(commands: readonly { command: string; words: Command }[], steps: readonly RunStep[]): readonly Invocation[] {
+  return steps.flatMap(({ location, blocker, script }) => {
+    const plain = plainCommand(script);
+    if (commands.some(({ words }) => invokes(plain, words))) return [{ location, blocker }];
+    const mentioned = commands.find(({ words }) => mentions(script, words));
+    if (mentioned === undefined) return [];
+    const alone = `the step runs more than ${mentioned.command}; give it its own step with nothing else in it`;
+    return [{ location, blocker: blocker ?? alone }];
+  });
+}
+
+const runsUnblocked = (invoking: readonly Invocation[]): boolean => invoking.some((step) => step.blocker === undefined);
+
 function gapsAmong(gates: readonly Gate[], steps: readonly RunStep[], lintGates: readonly KitGate[]): readonly Gap[] {
   return gates.flatMap((gate) => {
     const entryPoint = entryPointCommand(gate.words, lintGates);
@@ -204,16 +222,10 @@ function gapsAmong(gates: readonly Gate[], steps: readonly RunStep[], lintGates:
       ...gate.alternatives.map((words) => ({ command: gate.command, words })),
       ...(entryPoint === undefined ? [] : [{ command: entryPoint.join(" "), words: entryPoint }]),
     ];
-    const invoking = steps.flatMap(({ location, blocker, script }) => {
-      const plain = plainCommand(script);
-      if (commands.some(({ words }) => invokes(plain, words))) return [{ location, blocker }];
-      const mentioned = commands.find(({ words }) => mentions(script, words));
-      if (mentioned === undefined) return [];
-      const alone = `the step runs more than ${mentioned.command}; give it its own step with nothing else in it`;
-      return [{ location, blocker: blocker ?? alone }];
-    });
-    if (invoking.some((step) => step.blocker === undefined)) return [];
-    const blocked = invoking.flatMap(({ location, blocker }) =>
+    const invoking = invocations(commands, steps);
+    const parts = gate.partition.map((words) => invocations([{ command: words.join(" "), words }], steps));
+    if (runsUnblocked(invoking) || (parts.length > 0 && parts.every(runsUnblocked))) return [];
+    const blocked = [...invoking, ...parts.flat()].flatMap(({ location, blocker }) =>
       blocker === undefined ? [] : [{ location, blocker }],
     );
     return [{ gate: gate.command, ...(entryPoint === undefined ? {} : { entryPoint: entryPoint.join(" ") }), blocked }];
@@ -252,11 +264,13 @@ export function requiredCommands(scripts: readonly string[]): readonly string[]
 }
 
 export function declarationFor(scripts: readonly string[], branch: string): Declaration {
+  const tiers = SPLIT_SUITE.every((name) => scripts.includes(name)) ? SPLIT_SUITE.map((name) => ["bun", "run", name]) : [];
   return {
     gates: requiredCommands(scripts).map((command) => ({
       command,
       words: command.split(" "),
       alternatives: command === TITLE_LINT ? TITLE_CALLS.map((call) => call.split(" ")) : [],
+      partition: command === WHOLE_SUITE ? tiers : [],
     })),
     defaultBranch: branch,
     lintGates: KIT_GATES,
@@ -277,7 +291,7 @@ function readsOverride(runsOn: unknown): boolean {
 function runnerFault(runsOn: unknown, mutation: boolean, visibility: Visibility): string | undefined {
   const overridden = readsOverride(runsOn);
   const pin = `set runs-on: [${MUTATION_RUNNER.join(", ")}]`;
-  if (mutation && overridden) return `a mutation job reads CI_RUNS_ON, so an override moves its full sweeps off winbox; ${pin}`;
+  if (mutation && overridden) return `a mutation job reads CI_RUNS_ON, so an override moves its mutation runs off winbox; ${pin}`;
   if (mutation) return visibility === "private" && !sameLabels(runsOn, MUTATION_RUNNER) ? `a mutation job in a private repository runs off winbox; ${pin}` : undefined;
   const hosted = typeof runsOn === "string" && HOSTED_OVERRIDE.test(runsOn.trim());
   if (hosted || (visibility !== "private" && !overridden)) return undefined;

package/src/delivery/commit-title.ts

@@ -23,8 +23,8 @@ const cliOf = Effect.fn("cliOf")(function* () {
 // The config ships with the kit, so it sits two levels above this file wherever the kit is installed.
 const configOf = Effect.fn("configOf")(function* () {
   const file = yield* Effect.try({
-    try: () => new URL("../../commitlint.config.js", import.meta.url),
-    catch: () => setup("cannot resolve commitlint.config.js from the installed kit"),
+    try: () => new URL("../../commitlint.config.ts", import.meta.url),
+    catch: () => setup("cannot resolve commitlint.config.ts from the installed kit"),
   });
   return yield* (yield* Path.Path).fromFileUrl(file);
 });

package/src/docs/copy-html.ts

@@ -0,0 +1,110 @@
+import { Effect, Schema } from "effect";
+import { HtmlElement, HtmlValidate, Rule, StaticConfigLoader, TextNode, staticResolver, type DOMReadyEvent, type Plugin } from "html-validate";
+import { collecting, separatorFindings, type Collector, type CopyFinding, type Place } from "./copy-text.ts";
+
+const PLUGIN = "copy";
+const RULE = `${PLUGIN}/separators`;
+
+const UNREAD: ReadonlySet<string> = new Set(["script", "style", "template", "pre"]);
+const CODE: ReadonlySet<string> = new Set(["code", "kbd", "samp", "var"]);
+const TEXT_ATTRIBUTES = ["alt", "title", "placeholder", "aria-label", "aria-description"] as const;
+const BUTTON_TYPES: ReadonlySet<string> = new Set(["submit", "button", "reset"]);
+const LABELLED: ReadonlySet<string> = new Set(["option", "optgroup"]);
+const META_COPY: ReadonlySet<string> = new Set(["description", "og:title", "og:description", "twitter:title", "twitter:description"]);
+
+// Code stands in as one character that is neither a letter nor a space, so a hyphen after it still reads as spaced.
+const HIDDEN = "\0";
+
+const NAMED: Readonly<Record<string, string>> = { mdash: "—", ndash: "–", nbsp: "\u00a0" };
+const ENTITY = /^&(?:#(\d{1,7})|#[xX]([0-9a-fA-F]{1,6})|([A-Za-z][A-Za-z0-9]{1,31}));/;
+const LARGEST_CODE_POINT = 0x10ffff;
+
+function decoded([, decimal, hex, name]: RegExpExecArray): string {
+  const point = decimal === undefined ? (hex === undefined ? undefined : Number.parseInt(hex, 16)) : Number(decimal);
+  if (point === undefined) return NAMED[name ?? ""] ?? HIDDEN;
+  return point > 0 && point <= LARGEST_CODE_POINT ? String.fromCodePoint(point) : HIDDEN;
+}
+
+function addSource(collector: Collector, source: string, from: Place): void {
+  let { line, column } = from;
+  let at = 0;
+  while (at < source.length) {
+    const entity = source.charAt(at) === "&" ? ENTITY.exec(source.slice(at)) : null;
+    const char = entity === null ? source.charAt(at) : decoded(entity);
+    const length = entity === null ? 1 : entity[0].length;
+    collector.add(char, { line, column });
+    if (char === "\n") {
+      line += 1;
+      column = 1;
+    } else column += length;
+    at += length;
+  }
+}
+
+function addAttribute(element: HtmlElement, key: string, attributes: Collector): void {
+  const attribute = element.getAttribute(key);
+  if (attribute === null || typeof attribute.value !== "string" || attribute.valueLocation === null) return;
+  addSource(attributes, attribute.value, attribute.valueLocation);
+  attributes.end();
+}
+
+function readAttributes(element: HtmlElement, attributes: Collector): void {
+  for (const key of TEXT_ATTRIBUTES) addAttribute(element, key, attributes);
+  const named = element.getAttributeValue("name") ?? element.getAttributeValue("property");
+  if (element.tagName === "meta" && named !== null && META_COPY.has(named)) addAttribute(element, "content", attributes);
+  const type = element.getAttributeValue("type")?.toLowerCase();
+  if (element.tagName === "input" && type !== undefined && BUTTON_TYPES.has(type)) addAttribute(element, "value", attributes);
+  if (LABELLED.has(element.tagName)) addAttribute(element, "label", attributes);
+}
+
+function readElement(element: HtmlElement, text: Collector, attributes: Collector): void {
+  readAttributes(element, attributes);
+  const inline = element.meta?.phrasing === true && element.tagName !== "br";
+  if (!inline) text.end();
+  if (CODE.has(element.tagName)) text.add(HIDDEN, element.location);
+  else if (!UNREAD.has(element.tagName)) readChildren(element, text, attributes);
+  if (!inline) text.end();
+}
+
+function readChildren(element: HtmlElement, text: Collector, attributes: Collector): void {
+  for (const child of element.childNodes) {
+    if (child instanceof TextNode) addSource(text, child.textContent, child.location);
+    else if (child instanceof HtmlElement) readElement(child, text, attributes);
+  }
+}
+
+class Separators extends Rule {
+  override setup(): void {
+    this.on("dom:ready", ({ document, source }: DOMReadyEvent) => {
+      const text = collecting();
+      const attributes = collecting();
+      readChildren(document.root, text, attributes);
+      for (const { line, column, message } of separatorFindings([...text.blocks(), ...attributes.blocks()])) {
+        this.report(null, message, { filename: source.filename, line, column, offset: 0, size: 1 });
+      }
+    });
+  }
+}
+
+const plugin: Plugin = { name: PLUGIN, rules: { [RULE]: Separators } };
+
+const validator = new HtmlValidate(
+  new StaticConfigLoader([staticResolver({ plugins: { [PLUGIN]: plugin } })], {
+    root: true,
+    elements: ["html5", { svg: { foreign: false }, math: { foreign: false } }],
+    plugins: [PLUGIN],
+    rules: { [RULE]: "error" },
+  }),
+);
+
+class CopyHtmlError extends Schema.TaggedError<CopyHtmlError>()("CopyHtmlError", { message: Schema.String }) {}
+
+export const htmlFindings = Effect.fn("htmlFindings")(function* (source: string, file: string) {
+  const { results } = yield* Effect.tryPromise({
+    try: () => validator.validateString(source, file),
+    catch: (cause) => new CopyHtmlError({ message: `html-validate cannot read ${file}: ${String(cause)}` }),
+  });
+  return results.flatMap(({ messages }) =>
+    messages.map(({ line, column, message, ruleId }) => ({ line, column, message: ruleId === RULE ? message : `does not parse as HTML: ${message}` })),
+  ) satisfies readonly CopyFinding[];
+});

package/src/docs/copy-text.ts

@@ -0,0 +1,70 @@
+import { bodyOf, carries, continues, scanMarkdown, SEPARATORS, type LineKind } from "./prose-matchers.ts";
+
+export type Place = { readonly line: number; readonly column: number };
+
+export type CopyFinding = Place & { readonly message: string };
+
+// Each place is the source position of the character at the same index in text.
+type Block = { readonly text: string; readonly places: readonly Place[] };
+
+export type Collector = {
+  readonly add: (char: string, place: Place) => void;
+  readonly end: () => void;
+  readonly blocks: () => readonly Block[];
+};
+
+const SPACE = /\s/;
+
+// A reader sees each run of white space as one space, so a hyphen wrapped onto the next line still reads as spaced.
+export function collecting(): Collector {
+  const done: Block[] = [];
+  let text = "";
+  let places: Place[] = [];
+  const add = (char: string, place: Place): void => {
+    const spaced = SPACE.test(char);
+    if (spaced && (text === "" || text.endsWith(" "))) return;
+    text += spaced ? " " : char;
+    places.push(place);
+  };
+  const end = (): void => {
+    if (text.trim() !== "") done.push({ text, places });
+    text = "";
+    places = [];
+  };
+  return {
+    add,
+    end,
+    blocks: () => {
+      end();
+      return done;
+    },
+  };
+}
+
+function blockFindings({ text, places }: Block): readonly CopyFinding[] {
+  return SEPARATORS.flatMap((rule) =>
+    [...text.matchAll(rule.find)].flatMap((match) => {
+      const place = places[match.index + match[0].length - match[0].trimStart().length];
+      return place === undefined ? [] : [{ ...place, message: carries(match[0], rule) }];
+    }),
+  );
+}
+
+export function separatorFindings(blocks: readonly Block[]): readonly CopyFinding[] {
+  return blocks.flatMap(blockFindings).toSorted((a, b) => a.line - b.line || a.column - b.column);
+}
+
+const READ_KINDS: ReadonlySet<LineKind> = new Set(["prose", "heading", "table", "html"]);
+
+export function markdownFindings(text: string): readonly CopyFinding[] {
+  const lines = scanMarkdown(text);
+  const collector = collecting();
+  for (const [index, line] of lines.entries()) {
+    if (!continues(lines[index - 1], line)) collector.end();
+    if (!READ_KINDS.has(line.kind)) continue;
+    const body = bodyOf(line);
+    for (let at = 0; at < body.length; at += 1) collector.add(body.charAt(at), { line: line.line, column: at + 1 });
+    collector.add("\n", { line: line.line, column: body.length + 1 });
+  }
+  return separatorFindings(collector.blocks());
+}