@avi2dg/checks 0.63.1 → 0.65.0

package/src/testing/affected-tests.ts

@@ -0,0 +1,261 @@
+import { Config, Effect, FileSystem, Option, Path, Schema } from "effect";
+import { pathsSinceMergeBase, workingTreeFiles } from "../core/git.ts";
+import { decodePullRequestEvent, pullRequestEndsOf } from "../core/lint.ts";
+import { classifyPath } from "../core/scope.ts";
+import { decodeBunfig, importedFile, importsOf, preloadPaths, resolved, TEST_TREE } from "./mutation-scope-graph.ts";
+
+export type Narrowing =
+  | { readonly kind: "full"; readonly because: string }
+  | { readonly kind: "files"; readonly files: readonly string[] };
+
+type SelfReference = {
+  readonly name: string;
+  readonly exports: ReadonlyMap<string, string>;
+};
+
+export type Repository = {
+  readonly files: readonly string[];
+  readonly sources: ReadonlyMap<string, string>;
+  readonly bins: ReadonlyMap<string, string>;
+  readonly self: SelfReference | undefined;
+  readonly preloads: readonly string[];
+};
+
+const FIXTURES = "tests/fixtures/";
+// A workflow runs the suite rather than being read by it, so a test that reads one names its path.
+const WORKFLOWS = ".github/";
+const TEST_FILE = /\.test\.tsx?$/;
+const SOURCE_FILE = /\.(?:[cm]?[jt]sx?|astro|svelte|vue|sh)$/;
+const LOCKFILES = new Set(["bun.lock", "bun.lockb", "package-lock.json", "npm-shrinkwrap.json", "yarn.lock", "pnpm-lock.yaml"]);
+const TOOL_PINS = new Set([".bun-version", ".npmrc", ".nvmrc", ".node-version", ".tool-versions"]);
+const CONFIG = /(?:^|\.)config\.(?:[cm]?[jt]s|json)$/;
+const STYLESHEET = /\.(?:css|scss|sass|less|pcss|styl)$/;
+const FONT = /\.(?:woff2?|ttf|otf|eot)$/;
+const LAYOUT = /^layout\./i;
+const LISTED_SEGMENTS = /["'`][ \t]*,[ \t]*["'`]/g;
+const TOKEN = /[\w.@/-]+/g;
+const LEADING_HOPS = /^(?:\.{1,2}\/|\/)+/;
+const BARE_IMPORT = /(?:from|import)\s*\(?\s*["']([^"'.][^"']*)["']|require\s*\(\s*["']([^"'.][^"']*)["']\s*\)/g;
+// Bun picks the first condition it knows, and types names no file it runs.
+const CONDITIONS = ["bun", "import", "default", "node", "require"];
+const BUILT = "the build";
+
+const basenameOf = (path: string): string => path.slice(path.lastIndexOf("/") + 1);
+const directoryNode = (directory: string): string => directory + "/";
+
+export function sharedReason(path: string, preloads: ReadonlySet<string>): string | undefined {
+  if (path.startsWith(FIXTURES)) return undefined;
+  const name = basenameOf(path);
+  const directories = path.split("/").slice(0, -1);
+  if (LOCKFILES.has(name)) return "a lockfile";
+  if ((classifyPath(path) === "workflow" && !path.startsWith(WORKFLOWS)) || CONFIG.test(name) || TOOL_PINS.has(name)) {
+    return "a config every test runs under";
+  }
+  if (preloads.has(path)) return "a file Bun preloads into every test";
+  if (path.startsWith(TEST_TREE) && !TEST_FILE.test(path)) return "a test helper";
+  if (STYLESHEET.test(name)) return "a stylesheet";
+  if (FONT.test(name) || directories.includes("fonts")) return "a font";
+  if (directories.includes("layouts") || LAYOUT.test(name)) return "a layout";
+  return undefined;
+}
+
+// A path mentioned by any trailing run of two or more of its segments, or in full, names it.
+function mentionKeys(path: string): readonly string[] {
+  const segments = path.split("/");
+  const keys = [path];
+  for (let start = 1; start <= segments.length - 2; start += 1) keys.push(segments.slice(start).join("/"));
+  return keys;
+}
+
+// Only a fixture is read by its directory; a source directory a file names is one it lists, as a runner does.
+function directoriesOf(path: string): readonly string[] {
+  if (!path.startsWith(FIXTURES)) return [];
+  const segments = path.split("/");
+  return segments.slice(1).map((_, end) => segments.slice(0, end + 1).join("/"));
+}
+
+function exportTarget(target: unknown): string | undefined {
+  if (typeof target === "string") return target;
+  if (typeof target !== "object" || target === null) return undefined;
+  const conditions: Readonly<Record<string, unknown>> = { ...target };
+  for (const condition of CONDITIONS) {
+    const found = exportTarget(conditions[condition]);
+    if (found !== undefined) return found;
+  }
+  return undefined;
+}
+
+function exportsMap(exports: unknown): ReadonlyMap<string, string> {
+  if (typeof exports === "string") return new Map([[".", resolved("", exports)]]);
+  if (typeof exports !== "object" || exports === null) return new Map();
+  const entries: Readonly<Record<string, unknown>> = { ...exports };
+  return new Map(Object.entries(entries).flatMap(([key, target]) => {
+    const file = exportTarget(target);
+    return file === undefined ? [] : [[key, resolved("", file)] as const];
+  }));
+}
+
+function selfTarget(spec: string, self: SelfReference): string | undefined {
+  if (spec !== self.name && !spec.startsWith(self.name + "/")) return undefined;
+  const subpath = spec === self.name ? "." : "./" + spec.slice(self.name.length + 1);
+  if (self.exports.size === 0) return resolved("", subpath === "." ? "index" : subpath);
+  const exact = self.exports.get(subpath);
+  if (exact !== undefined) return exact;
+  for (const [key, target] of self.exports) {
+    const star = key.indexOf("*");
+    if (star === -1) continue;
+    const [before, after] = [key.slice(0, star), key.slice(star + 1)];
+    if (subpath.startsWith(before) && subpath.endsWith(after) && subpath.length >= key.length - 1) {
+      return target.replace("*", subpath.slice(before.length, subpath.length - after.length));
+    }
+  }
+  return BUILT;
+}
+
+type Graph = { readonly readers: ReadonlyMap<string, ReadonlySet<string>>; readonly builtReaders: ReadonlySet<string> };
+
+function linkTo(readers: Map<string, Set<string>>, read: string, reader: string): void {
+  if (read === reader) return;
+  readers.set(read, (readers.get(read) ?? new Set()).add(reader));
+}
+
+function selfImports(text: string, self: SelfReference, known: ReadonlySet<string>): readonly string[] {
+  return [...text.matchAll(BARE_IMPORT)].flatMap(([, viaImport = "", viaRequire = ""]) => {
+    const target = selfTarget(viaImport || viaRequire, self);
+    if (target === undefined || target === BUILT) return target === undefined ? [] : [BUILT];
+    const found = importedFile(target, known);
+    return found.length === 0 ? [BUILT] : found;
+  });
+}
+
+function mentioned(text: string, index: ReadonlyMap<string, readonly string[]>): readonly string[] {
+  const joined = text.replaceAll(LISTED_SEGMENTS, "/");
+  return [...joined.matchAll(TOKEN)].flatMap(([token]) => index.get(token.replace(LEADING_HOPS, "").replace(/\/$/, "")) ?? []);
+}
+
+function mentionIndex(repository: Repository, known: ReadonlySet<string>): ReadonlyMap<string, readonly string[]> {
+  const index = new Map<string, string[]>();
+  const add = (key: string, node: string) => index.set(key, [...(index.get(key) ?? []), node]);
+  const directories = new Set([...known].flatMap(directoriesOf));
+  for (const file of known) for (const key of mentionKeys(file)) add(key, file);
+  for (const directory of directories) for (const key of mentionKeys(directory)) if (key.includes("/")) add(key, directoryNode(directory));
+  for (const [bin, file] of repository.bins) add(bin, file);
+  return index;
+}
+
+function graphOf(repository: Repository, changed: readonly string[]): Graph {
+  const known = new Set([...repository.files, ...changed]);
+  const index = mentionIndex(repository, known);
+  const readers = new Map<string, Set<string>>();
+  const builtReaders = new Set<string>();
+  for (const [file, text] of repository.sources) {
+    const self = repository.self === undefined ? [] : selfImports(text, repository.self, known);
+    if (self.includes(BUILT)) builtReaders.add(file);
+    const named = file.startsWith(TEST_TREE) ? mentioned(text, index) : [];
+    for (const read of [...importsOf(file, text, known), ...self.filter((target) => target !== BUILT), ...named]) {
+      linkTo(readers, read, file);
+    }
+  }
+  return { readers, builtReaders };
+}
+
+function reach(graph: Graph, changed: readonly string[], sources: ReadonlyMap<string, string>): ReadonlySet<string> {
+  const reached = new Set<string>();
+  const pending = [...changed];
+  const builds = changed.some((path) => sources.has(path) && !path.startsWith(TEST_TREE));
+  if (builds) pending.push(...graph.builtReaders);
+  for (let node = pending.pop(); node !== undefined; node = pending.pop()) {
+    if (reached.has(node)) continue;
+    reached.add(node);
+    pending.push(...(graph.readers.get(node) ?? []));
+    if (!node.endsWith("/")) pending.push(...directoriesOf(node).map(directoryNode));
+  }
+  return reached;
+}
+
+function preloadClosure(repository: Repository): ReadonlySet<string> {
+  const known = new Set(repository.files);
+  const loaded = new Set<string>();
+  for (let pending = [...repository.preloads]; pending.length > 0; ) {
+    const file = pending.pop() ?? "";
+    if (loaded.has(file)) continue;
+    loaded.add(file);
+    pending.push(...importsOf(file, repository.sources.get(file) ?? "", known));
+  }
+  return loaded;
+}
+
+// A test or its helper reads a file it imports or names by path or bin, and a source reads only what it imports, at any depth.
+// A source that names a path, as a registry does, would make every importer read every file it lists.
+export function narrowTests(changed: readonly string[], repository: Repository, tests: readonly string[]): Narrowing {
+  if (changed.length === 0) return { kind: "full", because: "the pull request changes no file" };
+  const preloads = preloadClosure(repository);
+  for (const path of changed) {
+    const reason = sharedReason(path, preloads);
+    if (reason !== undefined) return { kind: "full", because: `the pull request changes ${path}, ${reason}` };
+  }
+  const reached = reach(graphOf(repository, changed), changed, repository.sources);
+  return { kind: "files", files: tests.filter((test) => reached.has(test)) };
+}
+
+const Manifest = Schema.Struct({
+  name: Schema.optionalKey(Schema.String),
+  exports: Schema.optionalKey(Schema.Unknown),
+  bin: Schema.optionalKey(Schema.Union([Schema.String, Schema.Record(Schema.String, Schema.String)])),
+});
+const decodeManifest = Schema.decodeUnknownEffect(Schema.fromJsonString(Manifest));
+
+class NarrowingError extends Schema.TaggedError<NarrowingError>()("NarrowingError", {
+  message: Schema.String,
+}) {}
+
+function binsOf(manifest: typeof Manifest.Type): ReadonlyMap<string, string> {
+  const { bin, name } = manifest;
+  if (bin === undefined) return new Map();
+  if (typeof bin === "string") return name === undefined ? new Map() : new Map([[basenameOf(name), resolved("", bin)]]);
+  return new Map(Object.entries(bin).map(([command, file]) => [command, resolved("", file)]));
+}
+
+const readRepository = Effect.fn("readRepository")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const files = yield* workingTreeFiles(root);
+  const read = (file: string) => fs.readFileString(path.join(root, file)).pipe(Effect.orElseSucceed(() => ""));
+  const sources = new Map(yield* Effect.forEach(files.filter((file) => SOURCE_FILE.test(file)), (file) =>
+    read(file).pipe(Effect.map((text) => [file, text] as const)), { concurrency: 16 }));
+  const manifest = files.includes("package.json") ? yield* read("package.json").pipe(Effect.flatMap(decodeManifest)) : {};
+  const bunfig = files.includes("bunfig.toml")
+    ? yield* read("bunfig.toml").pipe(
+        Effect.flatMap((text) => Effect.try({ try: (): unknown => Bun.TOML.parse(text), catch: (cause) => new NarrowingError({ message: "cannot parse bunfig.toml: " + String(cause) }) })),
+        Effect.flatMap(decodeBunfig),
+      )
+    : {};
+  return {
+    files,
+    sources,
+    bins: binsOf(manifest),
+    self: manifest.name === undefined ? undefined : { name: manifest.name, exports: exportsMap(manifest.exports) },
+    preloads: preloadPaths(bunfig),
+  } satisfies Repository;
+});
+
+const pullRequestEvent = Config.all({
+  name: Config.String("GITHUB_EVENT_NAME").pipe(Config.withDefault("")),
+  path: Config.String("GITHUB_EVENT_PATH").pipe(Config.withDefault("")),
+});
+
+// Only a pull_request run has a base to diff against; every other run keeps the suite whole.
+export const readPullRequestNarrowing = Effect.fn("readPullRequestNarrowing")(function* (root: string, tests: readonly string[]) {
+  const event = yield* pullRequestEvent.pipe(Effect.orElseSucceed(() => ({ name: "", path: "" })));
+  if (event.name !== "pull_request" || event.path === "") return Option.none<Narrowing>();
+  const narrowing = Effect.gen(function* () {
+    const text = yield* (yield* FileSystem.FileSystem).readFileString(event.path);
+    const { pull_request: pullRequest } = yield* decodePullRequestEvent(text);
+    const { base, head } = pullRequestEndsOf(pullRequest);
+    const changed = yield* pathsSinceMergeBase(base, head, root);
+    return narrowTests(changed, yield* readRepository(root), tests);
+  });
+  return Option.some(yield* narrowing.pipe(
+    Effect.catch((cause) => Effect.succeed<Narrowing>({ kind: "full", because: "the pull request's changes cannot be read: " + cause.message })),
+  ));
+});

package/src/testing/mutation-scope-graph.ts

@@ -1,3 +1,5 @@
+import { Schema } from "effect";
+
 export const TEST_TREE = "tests/";
 const FIXTURES = "tests/fixtures/";
 const CANDIDATE_EXTENSIONS = [".tsx", ".ts", ".mts", ".cts", ".jsx", ".js", ".mjs", ".cjs", ".json", ".node"];
@@ -6,6 +8,17 @@ const IMPORT = /(?:from|import)\s*\(?\s*["'](\.[^"']*)["']|require\s*\(\s*["'](\
 const LISTED_SEGMENTS = /["'`][ \t]*,[ \t]*["'`]/g;
 const DIRECTORY_ENDS = ['"', "'", "`", '/"', "/'", "/`", "/${"];
 
+const Bunfig = Schema.Struct({
+  test: Schema.optionalKey(Schema.Struct({ preload: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(Schema.String)])) })),
+});
+
+export const decodeBunfig = Schema.decodeUnknownEffect(Bunfig);
+
+export function preloadPaths(bunfig: typeof Bunfig.Type): readonly string[] {
+  const preload = bunfig.test?.preload ?? [];
+  return (typeof preload === "string" ? [preload] : preload).map((entry) => resolved("", entry));
+}
+
 type Needle = { readonly text: string; readonly kind: "file" | "directory"; readonly fixture: string };
 
 export function resolved(directory: string, spec: string): string {

package/src/testing/mutation-scope.ts

@@ -3,7 +3,7 @@ import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { escape, minimatch } from "minimatch";
 import { changedPaths, git, pathsAt, pathsOf, rangeEnds, type Change } from "../core/git.ts";
 import { runMain, Usage } from "../core/main.ts";
-import { importedFile, importsOf, readersOf, resolved, TEST_TREE } from "./mutation-scope-graph.ts";
+import { decodeBunfig, importedFile, importsOf, preloadPaths, readersOf, resolved, TEST_TREE } from "./mutation-scope-graph.ts";
 
 const NAME = "mutation-scope";
 const USAGE = "usage: mutation-scope.ts <base> [full-baseline-report]";
@@ -53,12 +53,6 @@ export type Baseline = typeof BaselineSchema.Type;
 
 const decodeBaseline = Schema.decodeUnknownEffect(Schema.fromJsonString(BaselineSchema));
 
-const decodeBunfig = Schema.decodeUnknownEffect(
-  Schema.Struct({
-    test: Schema.optionalKey(Schema.Struct({ preload: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(Schema.String)])) })),
-  }),
-);
-
 export type MutationScope = { readonly scope: readonly string[]; readonly staleTests: readonly string[] };
 
 export type Picked = {
@@ -173,8 +167,7 @@ const preloadsAt = Effect.fn("preloadsAt")(function* (rev: string, paths: Readon
   const text = yield* git(["show", `${rev}:${BUNFIG}`]);
   const unparsed = () => new ScopeError({ message: `${BUNFIG} at ${rev} does not parse as TOML whose [test] preload is a path or a list of paths` });
   const bunfig = yield* Effect.try({ try: (): unknown => Bun.TOML.parse(text), catch: unparsed }).pipe(Effect.flatMap(decodeBunfig), Effect.mapError(unparsed));
-  const preload = bunfig.test?.preload ?? [];
-  return (typeof preload === "string" ? [preload] : preload).map((entry) => resolved("", entry));
+  return preloadPaths(bunfig);
 });
 
 const transitivelyImported = Effect.fn("transitivelyImported")(function* (rev: string, roots: readonly string[], paths: ReadonlySet<string>) {

package/src/testing/night-run-findings.ts

@@ -20,7 +20,8 @@ export type Finding =
   | { readonly kind: "mutation"; readonly file: string; readonly before: Score; readonly after: Score; readonly since: string }
   | { readonly kind: "test"; readonly file: string; readonly name: string }
   | { readonly kind: "crash"; readonly file: string }
-  | { readonly kind: "gates"; readonly file: string };
+  | { readonly kind: "gates"; readonly file: string }
+  | { readonly kind: "mutation-report"; readonly file: string };
 
 function scoreOf(file: ReportFile): Score {
   let detected = 0;
@@ -44,12 +45,13 @@ function fell(before: Score, after: Score): boolean {
 }
 
 // A night judges a key only from a report it read, since a report it lacks leaves every finding in it absent.
-export type Observed = { readonly tests: boolean; readonly gates: boolean; readonly mutation: boolean };
+export type Observed = { readonly tests: boolean; readonly gates: boolean; readonly mutation: boolean; readonly mutationReports: ReadonlySet<string> };
 
 export function keyOf(finding: Finding): string {
   if (finding.kind === "mutation") return `mutation:${finding.file}`;
   if (finding.kind === "test") return `test:${finding.file}${NAME_SEPARATOR}${finding.name}`;
   if (finding.kind === "gates") return `gates:${finding.file}`;
+  if (finding.kind === "mutation-report") return `mutation-report:${finding.file}`;
   return `test:${finding.file}`;
 }
 
@@ -70,8 +72,8 @@ function testFindings(reports: readonly TestReport[]): readonly Finding[] {
   return [...new Map(failing.map((finding) => [keyOf(finding), finding])).values()];
 }
 
-export function findingsOf(previous: Option.Option<PreviousNight>, tonight: Tonight, gates: readonly Finding[] = []): readonly Finding[] {
-  return [...scoreFindings(previous, tonight.scores), ...testFindings(tonight.tests), ...gates].sort((one, other) =>
+export function findingsOf(previous: Option.Option<PreviousNight>, tonight: Tonight, others: readonly Finding[] = []): readonly Finding[] {
+  return [...scoreFindings(previous, tonight.scores), ...testFindings(tonight.tests), ...others].sort((one, other) =>
     keyOf(one).localeCompare(keyOf(other)),
   );
 }
@@ -97,6 +99,7 @@ export function gatesDecided(log: string): boolean {
 export function cleared(key: string, present: ReadonlySet<string>, observed: Observed): boolean {
   if (present.has(key)) return false;
   if (key.startsWith("gates:")) return observed.gates;
+  if (key.startsWith("mutation-report:")) return observed.mutationReports.has(key.slice("mutation-report:".length));
   if (!key.startsWith("test:")) return false;
   const [file] = key.slice("test:".length).split(NAME_SEPARATOR);
   return observed.tests && !present.has(`test:${file}`);

package/src/testing/night-run.ts

@@ -4,12 +4,12 @@ import { ChildProcessSpawner } from "effect/process";
 import { DEFAULT_BRANCH } from "../core/gates.ts";
 import { runMain, Usage } from "../core/main.ts";
 import { gh, type GitHubFailure, gitHubJson, REPOSITORY } from "../delivery/github.ts";
-import { parseReport as parseMutationReport } from "./mutation-compare.ts";
+import { parseReport as parseMutationReport, type ReportFile } from "./mutation-compare.ts";
 import { cleared, type Finding, findingsOf, gatesDecided, gatesOf, keyOf, NightRecordSchema, noted, type Observed, type NightRecord, percent, type PreviousNight, scoresOf, type TestReport } from "./night-run-findings.ts";
 import { parseReport as parseTestReport } from "./test-report.ts";
 
 const NAME = "checks-night-run";
-const USAGE = `usage: ${NAME} [--mutation <mutation-report>] [--tests <junit-report>]... [--gates <lint-log>]`;
+const USAGE = `usage: ${NAME} [--mutation <mutation-report>]... [--tests <junit-report>]... [--gates <lint-log>]`;
 export const LABEL = "night-run";
 const LABEL_COLOR = "5319e7";
 const LABEL_DESCRIPTION = "A regression a night run on main found";
@@ -23,7 +23,7 @@ class NightRunFailure extends Schema.TaggedError<NightRunFailure>()("NightRunFai
   message: Schema.String,
 }) {}
 
-export type Options = { readonly mutation: Option.Option<string>; readonly tests: readonly string[]; readonly gates: Option.Option<string> };
+export type Options = { readonly mutation: readonly string[]; readonly tests: readonly string[]; readonly gates: Option.Option<string> };
 
 export const parseArgs = Effect.fnUntraced(function* (argv: readonly string[]): Effect.fn.Return<Options, Usage> {
   const mutation: string[] = [];
@@ -35,10 +35,10 @@ export const parseArgs = Effect.fnUntraced(function* (argv: readonly string[]):
     if (into === undefined || value === undefined || value.startsWith("--")) return yield* new Usage({ message: USAGE });
     into.push(value);
   }
-  if (mutation.length > 1 || gates.length > 1 || mutation.length + tests.length + gates.length === 0) {
+  if (gates.length > 1 || mutation.length + tests.length + gates.length === 0) {
     return yield* new Usage({ message: USAGE });
   }
-  return { mutation: Option.fromNullishOr(mutation[0]), tests, gates: Option.fromNullishOr(gates[0]) };
+  return { mutation, tests, gates: Option.fromNullishOr(gates[0]) };
 });
 
 export type OpenIssue = { readonly number: number; readonly key: string };
@@ -120,6 +120,7 @@ function fullTitleOf(finding: Finding): string {
   if (finding.kind === "mutation") return `Night run: mutation score fell in ${finding.file}`;
   if (finding.kind === "test") return `Night run: ${finding.file} > ${finding.name} fails`;
   if (finding.kind === "gates") return `Night run: nightly gate ${finding.file} failed`;
+  if (finding.kind === "mutation-report") return `Night run: no mutation report at ${finding.file}`;
   return `Night run: ${finding.file} crashed its test worker`;
 }
 
@@ -144,6 +145,7 @@ export function findingText(finding: Finding, run: string): string {
   }
   if (finding.kind === "test") return `The night run ${run} failed \`${finding.name}\` in \`${finding.file}\`.`;
   if (finding.kind === "gates") return `The night run ${run} failed nightly gate \`${finding.file}\`.`;
+  if (finding.kind === "mutation-report") return `The night run ${run} found no mutation report at \`${finding.file}\`: the mutation job that writes it failed, timed out or was cancelled, so no file it mutates was scored.`;
   return `The night run ${run} lost every result of \`${finding.file}\`, because the worker running it crashed.`;
 }
 
@@ -264,13 +266,33 @@ const writeRecord = Effect.fn("writeRecord")(function* (record: NightRecord) {
   yield* fs.writeFileString(RECORD, `${JSON.stringify(record, null, 2)}\n`);
 });
 
-const tonightScores = Effect.fn("tonightScores")(function* (file: string) {
-  return scoresOf(yield* parseMutationReport(file, yield* readText(file)));
+type MutationReport = { readonly file: string; readonly files: Option.Option<ReadonlyMap<string, ReportFile>> };
+
+// A mutation job that timed out or failed uploads no report, so a missing file is a finding rather than a failed read.
+const mutationReport = Effect.fn("mutationReport")(function* (file: string) {
+  if (!(yield* (yield* FileSystem.FileSystem).exists(file).pipe(Effect.mapError(unreadable(file))))) return { file, files: Option.none() } satisfies MutationReport;
+  return { file, files: Option.some(yield* parseMutationReport(file, yield* readText(file))) } satisfies MutationReport;
 });
 
+function missingReports(reports: readonly MutationReport[]): readonly Finding[] {
+  return reports.flatMap(({ file, files }): readonly Finding[] => (Option.isNone(files) ? [{ kind: "mutation-report", file }] : []));
+}
+
+function readReports(reports: readonly MutationReport[]): ReadonlySet<string> {
+  return new Set(reports.flatMap(({ file, files }) => (Option.isSome(files) ? [file] : [])));
+}
+
+function tonightScores(reports: readonly MutationReport[]): Option.Option<NightRecord["scores"]> {
+  const read = reports.flatMap(({ files }) => (Option.isSome(files) ? [...files.value] : []));
+  return reports.some(({ files }) => Option.isSome(files)) ? Option.some(scoresOf(new Map(read))) : Option.none();
+}
+
 type Filing = { readonly onMain: true; readonly filed: readonly Filed[] } | { readonly onMain: false; readonly ref: string };
 
-export function report(run: string, scored: Option.Option<number>, previous: Option.Option<PreviousNight>, findings: readonly Finding[], filing: Filing): string {
+// A night missing one report records nothing, so the next night still compares every file with the last night that scored it.
+type Scored = { readonly files: number; readonly missing: number };
+
+export function report(run: string, scored: Option.Option<Scored>, previous: Option.Option<PreviousNight>, findings: readonly Finding[], filing: Filing): string {
   const against = Option.isNone(scored)
     ? "had no mutation report, so it compared no score"
     : Option.isSome(previous)
@@ -280,25 +302,30 @@ export function report(run: string, scored: Option.Option<number>, previous: Opt
   const listed = filing.onMain ? filing.filed.map((one) => `  ${one.action} #${one.issue} for ${one.key}`) : findings.map((finding) => `  found ${keyOf(finding)}`);
   const recorded = !filing.onMain
     ? `${NAME}: the run is on ${filing.ref}, not ${DEFAULT_BRANCH}, so it filed no issue and recorded no score`
-    : Option.isSome(scored)
-      ? `${NAME}: recorded ${scored.value} file score(s) in ${RECORD}`
-      : `${NAME}: recorded no score, since it had no mutation report`;
+    : Option.isNone(scored)
+      ? `${NAME}: recorded no score, since it had no mutation report`
+      : scored.value.missing === 0
+        ? `${NAME}: recorded ${scored.value.files} file score(s) in ${RECORD}`
+        : `${NAME}: recorded no score, since ${scored.value.missing} mutation report(s) were missing`;
   return [`${NAME}: the night run ${run} ${against}; ${verdict}`, ...listed, recorded].join("\n");
 }
 
 const nightRun = Effect.gen(function* () {
   const options = yield* parseArgs(process.argv.slice(2));
   const actions = yield* actionsRun;
-  const scores = Option.isSome(options.mutation) ? Option.some(yield* tonightScores(options.mutation.value)) : Option.none<NightRecord["scores"]>();
+  const reports = yield* Effect.forEach(options.mutation, mutationReport);
+  const missing = missingReports(reports);
+  const scores = tonightScores(reports);
   const tests: TestReport[] = yield* Effect.forEach(options.tests, testReport);
   const log = Option.isSome(options.gates) ? Option.some(yield* readText(options.gates.value)) : Option.none<string>();
   const gates: readonly Finding[] = Option.isSome(log) ? gatesOf(log.value) : [];
   const previous = Option.isSome(scores) ? yield* previousNight(actions) : Option.none<PreviousNight>();
-  const observed: Observed = { tests: options.tests.length > 0, gates: Option.isSome(log) && gatesDecided(log.value), mutation: Option.isSome(previous) };
-  const findings = findingsOf(previous, { scores: Option.getOrElse(scores, () => ({})), tests }, gates);
+  const observed: Observed = { tests: options.tests.length > 0, gates: Option.isSome(log) && gatesDecided(log.value), mutation: Option.isSome(previous) && missing.length === 0, mutationReports: readReports(reports) };
+  const findings = findingsOf(previous, { scores: Option.getOrElse(scores, () => ({})), tests }, [...missing, ...gates]);
   const filing: Filing = actions.ref === `refs/heads/${DEFAULT_BRANCH}` ? { onMain: true, filed: yield* fileFindings(findings, observed, actions.run) } : { onMain: false, ref: actions.ref };
-  if (filing.onMain && Option.isSome(scores)) yield* writeRecord({ scores: scores.value });
-  yield* Console.log(report(actions.run, Option.map(scores, (tonight) => Object.keys(tonight).length), previous, findings, filing));
+  if (filing.onMain && Option.isSome(scores) && missing.length === 0) yield* writeRecord({ scores: scores.value });
+  const scored = Option.map(scores, (tonight): Scored => ({ files: Object.keys(tonight).length, missing: missing.length }));
+  yield* Console.log(report(actions.run, scored, previous, findings, filing));
   return true;
 });
 

package/src/testing/test-skips.ts

@@ -138,13 +138,13 @@ function declarationsIn(source: string, file: string, module: unknown): Declarat
   return { kind: "valid", declarations };
 }
 
-function selectedTierFile(file: string, tier: TestTier | undefined): boolean {
+export function selectedTierFile(file: string, tier: TestTier | undefined): boolean {
   if (file.startsWith("tests/quarantine/")) return false;
   if (tier === undefined) return !file.startsWith("tests/live/") && !file.startsWith("tests/pixel/");
   return file.startsWith(`tests/${tier}/`);
 }
 
-const scanTestFiles = Effect.fn("scanTestFiles")(function* (root: string) {
+export const scanTestFiles = Effect.fn("scanTestFiles")(function* (root: string) {
   return yield* Effect.tryPromise({
     try: () =>
       Promise.all(
@@ -156,7 +156,7 @@ const scanTestFiles = Effect.fn("scanTestFiles")(function* (root: string) {
   });
 });
 
-const readDeclarationsIn = Effect.fn("readDeclarationsIn")(function* (root: string, files: readonly string[]) {
+export const readDeclarationsIn = Effect.fn("readDeclarationsIn")(function* (root: string, files: readonly string[]) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const declarations: SkipDeclaration[] = [];

package/src/testing/test.ts

@@ -4,9 +4,13 @@ import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effec
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { TEST_ENTRY_POINT } from "../core/gates.ts";
 import { runMain, Usage } from "../core/main.ts";
+import { readPullRequestNarrowing } from "./affected-tests.ts";
 import {
+  readDeclarationsIn,
   readSkipDeclarations,
   readSmokeDeclarations,
+  scanTestFiles,
+  selectedTierFile,
   type Environment,
   type SkipDeclaration,
   type TestTier,
@@ -171,7 +175,8 @@ const environmentOf = Config.Boolean("CI").pipe(
 export type SuiteSelection =
   | { readonly kind: "full" }
   | { readonly kind: "tier"; readonly tier: TestTier }
-  | { readonly kind: "smoke" };
+  | { readonly kind: "smoke" }
+  | { readonly kind: "files"; readonly files: readonly string[] };
 
 export function selectSuite(options: TestOptions, environment: Environment): SuiteSelection {
   if (options.tier !== undefined) return { kind: "tier", tier: options.tier };
@@ -191,6 +196,7 @@ export function smokeList(manifest: unknown): readonly string[] | undefined {
 export function suiteArgs(selection: SuiteSelection, smoke: readonly string[]): readonly string[] {
   if (selection.kind === "tier") return tierArgs(selection.tier);
   if (selection.kind === "smoke") return ["./tests/unit", ...smoke.map((file) => `./${file}`)];
+  if (selection.kind === "files") return selection.files.map((file) => `./${file}`);
   return [];
 }
 
@@ -218,6 +224,37 @@ const readSmokeList = Effect.fn("readSmokeList")(function* (root: string) {
   return smoke;
 });
 
+// A live or pixel tier and --full run whole, since no pull request picks them.
+export function narrowedTier(options: TestOptions, selection: SuiteSelection): { readonly tier: TestTier | undefined } | undefined {
+  if (options.full === true) return undefined;
+  if (selection.kind === "full") return { tier: undefined };
+  if (selection.kind === "tier" && (selection.tier === "unit" || selection.tier === "e2e")) return { tier: selection.tier };
+  return undefined;
+}
+
+const narrowSelection = Effect.fn("narrowSelection")(function* (options: TestOptions, selection: SuiteSelection, environment: Environment) {
+  const narrowed = narrowedTier(options, selection);
+  if (environment !== "ci" || narrowed === undefined) return selection;
+  const tests = (yield* scanTestFiles(process.cwd())).filter((file) => selectedTierFile(file, narrowed.tier));
+  const narrowing = yield* readPullRequestNarrowing(process.cwd(), tests);
+  if (Option.isNone(narrowing)) return selection;
+  if (narrowing.value.kind === "full") {
+    yield* Console.log(`${NAME}: ${narrowing.value.because}, so the whole suite runs`);
+    return selection;
+  }
+  yield* Console.log(`${NAME}: the pull request reaches ${narrowing.value.files.length} of ${tests.length} test file(s)`);
+  return { kind: "files", files: narrowing.value.files } satisfies SuiteSelection;
+});
+
+const readScope = Effect.fn("readScope")(function* (selection: SuiteSelection, smoke: readonly string[]) {
+  if (selection.kind === "smoke") return yield* readSmokeDeclarations(process.cwd(), smoke);
+  const declarations =
+    selection.kind === "files"
+      ? yield* readDeclarationsIn(process.cwd(), selection.files)
+      : yield* readSkipDeclarations(process.cwd(), selection.kind === "tier" ? selection.tier : undefined);
+  return { files: undefined, declarations };
+});
+
 const runSuite = Effect.fn("runSuite")(function* (outfile: string, args: readonly string[], workers: number | undefined) {
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const command = ["test", "--randomize", `--parallel=${workerCount(workers)}`, ...args, ...reporterArgs(outfile)];
@@ -239,15 +276,13 @@ const testEntry = Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const environment = yield* environmentOf;
-  const selection = selectSuite(options, environment);
+  const selection = yield* narrowSelection(options, selectSuite(options, environment), environment);
+  if (selection.kind === "files" && selection.files.length === 0) {
+    yield* Console.log(`${NAME}: the pull request changes no file a test reads, so no test ran`);
+    return true;
+  }
   const smoke = selection.kind === "smoke" ? yield* readSmokeList(process.cwd()) : [];
-  const scope =
-    selection.kind === "smoke"
-      ? yield* readSmokeDeclarations(process.cwd(), smoke)
-      : {
-          files: undefined,
-          declarations: yield* readSkipDeclarations(process.cwd(), selection.kind === "tier" ? selection.tier : undefined),
-        };
+  const scope = yield* readScope(selection, smoke);
   if (scope.files?.length === 0) {
     yield* Console.log(`${NAME}: no unit test and no smoke list, so this local run ran nothing; declare checks.smoke or pass ${FULL}`);
     return true;
@@ -257,6 +292,18 @@ const testEntry = Effect.gen(function* () {
   const outfile = path.join(yield* fs.makeTempDirectoryScoped({ prefix: "checks-test-" }), "junit.xml");
   const suitePassed =
     (yield* runSuite(outfile, suiteArgs(selection, smoke), options.workers)) === ChildProcessSpawner.ExitCode(0);
+  return yield* judgeRun(outfile, junit, suitePassed, declarations, environment);
+}).pipe(Effect.scoped);
+
+const judgeRun = Effect.fn("judgeRun")(function* (
+  outfile: string,
+  junit: Option.Option<string>,
+  suitePassed: boolean,
+  declarations: Parameters<typeof judgeSkips>[1],
+  environment: Environment,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
   const written = yield* fs.exists(outfile);
   if (written && Option.isSome(junit)) {
     yield* fs.makeDirectory(path.dirname(junit.value), { recursive: true });
@@ -276,6 +323,6 @@ const testEntry = Effect.gen(function* () {
   const verdict = judgeSkips(results, judged, environment);
   yield* passes(verdict) ? Console.log(report(verdict)) : Console.error(report(verdict));
   return suitePassed && crashedFiles.length === 0 && passes(verdict);
-}).pipe(Effect.scoped);
+});
 
 if (import.meta.main) runMain(NAME, testEntry);