@avi2dg/checks 0.50.1 → 0.52.0

package/src/testing/mutation-baseline-saved.ts

@@ -40,6 +40,58 @@ const slimOf = Effect.fn("slimOf")(function* (from: string) {
   return withoutReasons(report);
 });
 
+export type Invalidation = { readonly tests: ReadonlySet<string>; readonly sources: ReadonlySet<string> };
+
+export type Invalidated = { readonly state: unknown; readonly tests: readonly string[]; readonly sources: readonly string[] };
+
+const isKilled = (mutant: unknown): boolean => isRecord(mutant) && mutant["status"] === "Killed";
+
+const staleTests = (state: Readonly<Record<string, unknown>>, invalidation: Invalidation): readonly string[] => {
+  const testFiles = state["testFiles"];
+  return isRecord(testFiles) ? Object.keys(testFiles).filter((file) => invalidation.tests.has(file)) : [];
+};
+
+const keptEntry = (file: unknown, stale: boolean, dropStatic: boolean): { readonly entry: unknown; readonly dropped: boolean } => {
+  if (!isRecord(file) || !Array.isArray(file["mutants"])) return { entry: file, dropped: false };
+  const before: readonly unknown[] = file["mutants"];
+  const mutants = stale ? [] : dropStatic ? before : before.filter(isKilled);
+  return { entry: mutants.length > 0 ? { ...file, mutants } : undefined, dropped: mutants.length < before.length };
+};
+
+const prunedFiles = (
+  state: Readonly<Record<string, unknown>>,
+  invalidation: Invalidation,
+): { readonly files: Record<string, unknown> | undefined; readonly sources: readonly string[] } => {
+  const files = state["files"];
+  if (!isRecord(files)) return { files: undefined, sources: [] };
+  const next: Record<string, unknown> = {};
+  const sources: string[] = [];
+  for (const [name, file] of Object.entries(files)) {
+    const kept = keptEntry(file, invalidation.sources.has(name), invalidation.tests.size === 0);
+    if (kept.entry !== undefined) next[name] = kept.entry;
+    if (kept.dropped) sources.push(name);
+  }
+  return { files: next, sources };
+};
+
+export function withoutStale(state: unknown, invalidation: Invalidation): Invalidated {
+  if (!isRecord(state)) return { state, tests: [], sources: [] };
+  const tests = staleTests(state, invalidation);
+  const pruned = prunedFiles(state, invalidation);
+  if (tests.length === 0 && pruned.sources.length === 0) return { state, tests: [], sources: [] };
+  return {
+    state: {
+      ...state,
+      ...(isRecord(state["testFiles"])
+        ? { testFiles: Object.fromEntries(Object.entries(state["testFiles"]).filter(([file]) => !invalidation.tests.has(file))) }
+        : {}),
+      ...(pruned.files === undefined ? {} : { files: pruned.files }),
+    },
+    tests: tests.toSorted(),
+    sources: pruned.sources.toSorted(),
+  };
+}
+
 export const slimmed = Effect.fn("slimmed")(function* (from: string, to: string) {
   const fs = yield* FileSystem.FileSystem;
   const report = yield* slimOf(from);

package/src/testing/mutation-baseline.ts

@@ -1,18 +1,13 @@
 #!/usr/bin/env bun
 import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effect";
-import { ChildProcessSpawner } from "effect/process";
-import { collect } from "../core/git.ts";
 import { runMain, Usage } from "../core/main.ts";
 import { cacheRoot } from "../dependencies/cache-root.ts";
+import { BaselineFailure, gh, pruneFullState } from "./mutation-baseline-full.ts";
 import { INCREMENTAL, LATEST_ARTIFACT, outlived, REPORT, saveBaseline, savedFiles, savedShelf, slimmed } from "./mutation-baseline-saved.ts";
 
-class BaselineFailure extends Schema.TaggedError<BaselineFailure>()("BaselineFailure", {
-  message: Schema.String,
-}) {}
-
 const NAME = "checks-mutation-baseline";
 const USAGE =
-  "usage: checks-mutation-baseline <incremental-dest> [mutation-json-dest] | --full <mutation-json-dest> | --save <incremental-src> [mutation-json-src] | --slim <mutation-json-src> <dest> | --prune [--dry-run]";
+  "usage: checks-mutation-baseline <incremental-dest> [mutation-json-dest] | --full <mutation-json-dest> [incremental-dest] | --save <incremental-src> [mutation-json-src] | --slim <mutation-json-src> <dest> | --prune [--dry-run]";
 const WORKFLOW = "mutation.yml";
 const BRANCH = "main";
 const REPORT_ALONE = "mutation.json";
@@ -40,13 +35,6 @@ type Artifact = typeof Artifact.Type;
 const decodeRuns = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Array(Run)));
 const decodeArtifacts = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ artifacts: Schema.Array(Artifact) })));
 
-const gh = Effect.fn("gh")(function* (args: readonly string[]) {
-  const failed = (reason: string): BaselineFailure => new BaselineFailure({ message: `gh ${args.join(" ")}: ${reason.trim()}` });
-  const { stdout, stderr, exitCode } = yield* collect("gh", args).pipe(Effect.mapError((cause) => failed(cause.message)));
-  if (exitCode !== ChildProcessSpawner.ExitCode(0)) return yield* failed(stderr);
-  return stdout;
-});
-
 const warned = <A>(fallback: A) => (failure: BaselineFailure) => Console.error(`mutation-baseline: ${failure.message}`).pipe(Effect.as(fallback));
 
 const listed = Effect.fn("listed")(function* (event: string | undefined, limit: number) {
@@ -58,14 +46,16 @@ const listed = Effect.fn("listed")(function* (event: string | undefined, limit:
   );
 });
 
+const byNewest = (runs: readonly Run[]): readonly Run[] => [...runs].sort((one, other) => other.createdAt.localeCompare(one.createdAt));
+
 export function newestFirst(runs: readonly Run[]): readonly number[] {
-  return [...runs].sort((one, other) => other.createdAt.localeCompare(one.createdAt)).map((run) => run.databaseId);
+  return byNewest(runs).map((run) => run.databaseId);
 }
 
 // All non-pull-request runs newest first: a newer full run holds no baseline, and the newest baseline must survive it.
 const latestCandidates = Effect.gen(function* () {
   const newest = (yield* listed(undefined, LATEST_LIMIT)).find((run) => run.event !== "pull_request");
-  return newest === undefined ? [] : [newest.databaseId];
+  return newest === undefined ? [] : [newest];
 });
 
 const latestRuns = listed(undefined, LATEST_LIMIT).pipe(Effect.map((runs) => newestFirst(runs.filter((run) => run.event !== "pull_request"))));
@@ -73,7 +63,7 @@ const latestRuns = listed(undefined, LATEST_LIMIT).pipe(Effect.map((runs) => new
 // Each full event is listed on its own, because one shared window lets push runs crowd out every full run.
 const fullCandidates = Effect.gen(function* () {
   const perEvent = yield* Effect.forEach(FULL_EVENTS, (event) => listed(event, FULL_LIMIT));
-  return newestFirst(perEvent.flat());
+  return byNewest(perEvent.flat());
 });
 
 // A successful run uploaded the files, so the newest unexpired artifact is the one the restore takes.
@@ -120,7 +110,7 @@ const keptLatest = Effect.fn("keptLatest")(function* (runs: readonly number[], s
 const pruneBaselines = Effect.fn("pruneBaselines")(function* (dryRun: boolean) {
   const running = yield* Config.Int("GITHUB_RUN_ID").pipe(Config.option);
   const latest = yield* keptLatest(yield* latestRuns, yield* savedShelf(yield* runnerCache));
-  const full = yield* keptArtifact(yield* fullCandidates, FULL_ARTIFACT);
+  const full = yield* keptArtifact((yield* fullCandidates).map((run) => run.databaseId), FULL_ARTIFACT);
   const artifacts = yield* everyArtifact();
   const keeping = [...Option.toArray(latest.kept), ...Option.toArray(full), ...uploadedBy(artifacts, running)];
   const victims = superseded(artifacts, new Set(keeping.map((keep) => keep.id)));
@@ -334,8 +324,15 @@ const FLAGS = new Map<string, (rest: readonly string[]) => Command | undefined>(
   ["--slim", ([from, to, ...extra]) => (isDestination(from) && isDestination(to) && extra.length === 0 ? { kind: "slim", from, to } : undefined)],
   [
     "--full",
-    ([report, ...extra]) =>
-      isDestination(report) && extra.length === 0 ? { kind: "restore", full: true, needed: { from: [REPORT_ALONE, REPORT], to: report }, optional: [] } : undefined,
+    ([report, incremental, ...extra]) =>
+      isDestination(report) && (incremental === undefined || isDestination(incremental)) && extra.length === 0
+        ? {
+            kind: "restore",
+            full: true,
+            needed: { from: [REPORT_ALONE, REPORT], to: report },
+            optional: incremental === undefined ? [] : [{ from: [INCREMENTAL], to: incremental }],
+          }
+        : undefined,
   ],
 ]);
 
@@ -346,14 +343,21 @@ function parsed([first, ...rest]: readonly string[]): Command | undefined {
   return restoreRequest(first, report, extra);
 }
 
+const restoredRun = Effect.fn("restoredRun")(function* (run: Run, name: string, root: Option.Option<string>, shelf: Option.Option<string>, request: Request) {
+  if (Option.isSome(shelf) && (yield* restoredFromSaved(shelf.value, run.databaseId, request))) return true;
+  const artifact = yield* artifactOf(run.databaseId, name).pipe(Effect.catch(warned(Option.none<Artifact>())));
+  if (Option.isNone(artifact) || !(yield* restoredFrom(run.databaseId, artifact.value, root, request))) return false;
+  const incremental = request.full ? request.optional[0] : undefined;
+  if (incremental !== undefined) yield* pruneFullState(run, incremental.to);
+  return true;
+});
+
 const restoreBaseline = Effect.fn("restoreBaseline")(function* (request: Request) {
   const name = request.full ? FULL_ARTIFACT : LATEST_ARTIFACT;
   const root = yield* runnerCache;
   const shelf = request.full ? Option.none<string>() : yield* savedShelf(root);
   for (const run of yield* request.full ? fullCandidates : latestCandidates) {
-    if (Option.isSome(shelf) && (yield* restoredFromSaved(shelf.value, run, request))) return true;
-    const artifact = yield* artifactOf(run, name).pipe(Effect.catch(warned(Option.none<Artifact>())));
-    if (Option.isSome(artifact) && (yield* restoredFrom(run, artifact.value, root, request))) return true;
+    if (yield* restoredRun(run, name, root, shelf, request)) return true;
   }
   yield* Console.log(`mutation-baseline: no successful ${BRANCH} run holds a ${name} artifact, so nothing was restored`);
   return true;

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

@@ -0,0 +1,89 @@
+export const TEST_TREE = "tests/";
+const FIXTURES = "tests/fixtures/";
+const CANDIDATE_EXTENSIONS = [".tsx", ".ts", ".mts", ".cts", ".jsx", ".js", ".mjs", ".cjs", ".json", ".node"];
+
+const IMPORT = /(?:from|import)\s*\(?\s*["'](\.[^"']*)["']|require\s*\(\s*["'](\.[^"']*)["']\s*\)/g;
+const LISTED_SEGMENTS = /["'`][ \t]*,[ \t]*["'`]/g;
+const DIRECTORY_ENDS = ['"', "'", "`", '/"', "/'", "/`", "/${"];
+
+type Needle = { readonly text: string; readonly kind: "file" | "directory"; readonly fixture: string };
+
+export function resolved(directory: string, spec: string): string {
+  const parts: string[] = [];
+  for (const part of `${directory}/${spec}`.split("/")) {
+    if (part === "..") parts.pop();
+    else if (part !== "." && part !== "") parts.push(part);
+  }
+  return parts.join("/");
+}
+
+// Bun takes the file a specifier names, then one with an extension added, and only then the directory's index.
+export function importedFile(path: string, files: ReadonlySet<string>): readonly string[] {
+  const bare = path.replace(/\.m?js$/, "");
+  const direct = [path, ...CANDIDATE_EXTENSIONS.map((extension) => bare + extension)].filter((file) => files.has(file));
+  if (direct.length > 0) return direct;
+  return CANDIDATE_EXTENSIONS.map((extension) => `${path}/index${extension}`).filter((file) => files.has(file));
+}
+
+function fixtureNeedles(changed: readonly string[]): readonly Needle[] {
+  const needles = new Map<string, Needle>();
+  for (const fixture of changed.filter((path) => path.startsWith(FIXTURES))) {
+    const text = fixture.slice(TEST_TREE.length);
+    needles.set(text, { text, kind: "file", fixture });
+    for (let end = text.lastIndexOf("/"); end > 0; end = text.lastIndexOf("/", end - 1)) {
+      const directory = text.slice(0, end);
+      if (!needles.has(directory)) needles.set(directory, { text: directory, kind: "directory", fixture });
+    }
+  }
+  return [...needles.values()];
+}
+
+function mentions(line: string, { text, kind }: Needle): boolean {
+  if (kind === "file") return line.includes(text);
+  return DIRECTORY_ENDS.some((end) => line.includes(text + end));
+}
+
+type Edge = { readonly importer: string; readonly imported: string };
+
+export function importsOf(file: string, text: string, files: ReadonlySet<string>): readonly string[] {
+  const directory = file.slice(0, Math.max(file.lastIndexOf("/"), 0));
+  return [...text.matchAll(IMPORT)].flatMap(([, throughImport = "", throughRequire = ""]) => importedFile(resolved(directory, throughImport || throughRequire), files));
+}
+
+const edgesOf = (file: string, text: string, files: ReadonlySet<string>): readonly Edge[] =>
+  importsOf(file, text, files).map((imported) => ({ importer: file, imported }));
+
+function fixtureNamedIn(text: string, needles: readonly Needle[]): string | undefined {
+  if (needles.length === 0) return undefined;
+  for (const line of text.split("\n")) {
+    const joined = line.replaceAll(LISTED_SEGMENTS, "/");
+    const needle = needles.find((each) => mentions(joined, each));
+    if (needle !== undefined) return needle.fixture;
+  }
+  return undefined;
+}
+
+function spread(reached: Map<string, string>, edges: readonly Edge[]): void {
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const { importer, imported } of edges) {
+      const via = reached.get(imported);
+      if (via === undefined || reached.has(importer)) continue;
+      reached.set(importer, via);
+      grew = true;
+    }
+  }
+}
+
+// Maps each file that reads a changed path, through an import or the fixture's path, to that changed path.
+export function readersOf(sources: ReadonlyMap<string, string>, changed: readonly string[]): Map<string, string> {
+  const reached = new Map(changed.map((path) => [path, path]));
+  const needles = fixtureNeedles(changed);
+  for (const [file, text] of sources) {
+    const fixture = reached.has(file) ? undefined : fixtureNamedIn(text, needles);
+    if (fixture !== undefined) reached.set(file, fixture);
+  }
+  const files = new Set([...sources.keys(), ...changed]);
+  spread(reached, [...sources].flatMap(([file, text]) => edgesOf(file, text, files)));
+  return new Map([...reached].filter(([file, via]) => file !== via));
+}

package/src/testing/mutation-scope.ts

@@ -3,17 +3,15 @@ import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { escape, minimatch } from "minimatch";
 import { changedPaths, git, pathsAt, 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";
 
 const NAME = "mutation-scope";
 const USAGE = "usage: mutation-scope.ts <base> [full-baseline-report]";
-const TEST_TREE = "tests/";
 const UNIT_TESTS = "tests/unit/";
-const FIXTURES = "tests/fixtures/";
 const TEST_FILE = /\.test\.tsx?$/;
 const READ_FILE = /\.tsx?$/;
 const BUNFIG = "bunfig.toml";
 const MUTATION_RANGE = /:\d+(?::\d+)?-\d+(?::\d+)?$/;
-const IMPORTED_EXTENSIONS = [".tsx", ".ts", ".mts", ".mjs", ".js"];
 
 export const STRYKER_DEFAULT_MUTATE = [
   "{src,lib}/**/!(*.+(s|S)pec|*.+(t|T)est).+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)",
@@ -21,7 +19,7 @@ export const STRYKER_DEFAULT_MUTATE = [
 ];
 
 // Stryker loads the first of these that exists, in this order.
-const STRYKER_CONFIGS = ["", "."].flatMap((dot) =>
+export const STRYKER_CONFIGS = ["", "."].flatMap((dot) =>
   [".conf", ".config"].flatMap((kind) => ["json", "js", "mjs", "cjs"].map((extension) => `${dot}stryker${kind}.${extension}`)),
 );
 
@@ -101,90 +99,7 @@ export function pickFromDiff(changes: readonly Change[], mutated: (file: string)
   };
 }
 
-const IMPORT = /(?:from|import)[ \t]*\(?[ \t]*["'](\.[^"']*)["']/g;
-const LISTED_SEGMENTS = /["'`][ \t]*,[ \t]*["'`]/g;
-const DIRECTORY_ENDS = ['"', "'", "`", '/"', "/'", "/`", "/${"];
-
-type Needle = { readonly text: string; readonly kind: "file" | "directory"; readonly fixture: string };
-
-function resolved(directory: string, spec: string): string {
-  const parts: string[] = [];
-  for (const part of `${directory}/${spec}`.split("/")) {
-    if (part === "..") parts.pop();
-    else if (part !== "." && part !== "") parts.push(part);
-  }
-  return parts.join("/");
-}
-
-// Bun takes the file a specifier names, then one with an extension added, and only then the directory's index.
-function importedFile(path: string, files: ReadonlySet<string>): string | undefined {
-  const bare = path.replace(/\.m?js$/, "");
-  const tried = [path, ...IMPORTED_EXTENSIONS.map((extension) => bare + extension), ...IMPORTED_EXTENSIONS.map((extension) => `${path}/index${extension}`)];
-  return tried.find((file) => files.has(file));
-}
-
-function fixtureNeedles(changed: readonly string[]): readonly Needle[] {
-  const needles = new Map<string, Needle>();
-  for (const fixture of changed.filter((path) => path.startsWith(FIXTURES))) {
-    const text = fixture.slice(TEST_TREE.length);
-    needles.set(text, { text, kind: "file", fixture });
-    for (let end = text.lastIndexOf("/"); end > 0; end = text.lastIndexOf("/", end - 1)) {
-      const directory = text.slice(0, end);
-      if (!needles.has(directory)) needles.set(directory, { text: directory, kind: "directory", fixture });
-    }
-  }
-  return [...needles.values()];
-}
-
-function mentions(line: string, { text, kind }: Needle): boolean {
-  if (kind === "file") return line.includes(text);
-  return DIRECTORY_ENDS.some((end) => line.includes(text + end));
-}
-
-type Edge = { readonly importer: string; readonly imported: string };
-
-function importsOf(file: string, text: string, files: ReadonlySet<string>): readonly string[] {
-  const directory = file.slice(0, Math.max(file.lastIndexOf("/"), 0));
-  return [...text.matchAll(IMPORT)].flatMap(([, spec = ""]) => importedFile(resolved(directory, spec), files) ?? []);
-}
-
-const edgesOf = (file: string, text: string, files: ReadonlySet<string>): readonly Edge[] =>
-  importsOf(file, text, files).map((imported) => ({ importer: file, imported }));
-
-function fixtureNamedIn(text: string, needles: readonly Needle[]): string | undefined {
-  if (needles.length === 0) return undefined;
-  for (const line of text.split("\n")) {
-    const joined = line.replaceAll(LISTED_SEGMENTS, "/");
-    const needle = needles.find((each) => mentions(joined, each));
-    if (needle !== undefined) return needle.fixture;
-  }
-  return undefined;
-}
-
-function spread(reached: Map<string, string>, edges: readonly Edge[]): void {
-  for (let grew = true; grew; ) {
-    grew = false;
-    for (const { importer, imported } of edges) {
-      const via = reached.get(imported);
-      if (via === undefined || reached.has(importer)) continue;
-      reached.set(importer, via);
-      grew = true;
-    }
-  }
-}
-
-// Maps each file that reads a changed path, through an import or the fixture's path, to that changed path.
-export function readersOf(sources: ReadonlyMap<string, string>, changed: readonly string[]): Map<string, string> {
-  const reached = new Map(changed.map((path) => [path, path]));
-  const needles = fixtureNeedles(changed);
-  for (const [file, text] of sources) {
-    const fixture = reached.has(file) ? undefined : fixtureNamedIn(text, needles);
-    if (fixture !== undefined) reached.set(file, fixture);
-  }
-  const files = new Set([...sources.keys(), ...changed]);
-  spread(reached, [...sources].flatMap(([file, text]) => edgesOf(file, text, files)));
-  return new Map([...reached].filter(([file, via]) => file !== via));
-}
+export { readersOf };
 
 // Names what every unit test loads that the branch changes: the preload list, a preload, or a file a preload imports.
 export function preloadChange(
@@ -264,24 +179,41 @@ const preloadsAt = Effect.fn("preloadsAt")(function* (rev: string, paths: Readon
   return (typeof preload === "string" ? [preload] : preload).map((entry) => resolved("", entry));
 });
 
-const loadedByPreloads = Effect.fn("loadedByPreloads")(function* (rev: string, preloads: readonly string[], paths: ReadonlySet<string>) {
+const transitivelyImported = Effect.fn("transitivelyImported")(function* (rev: string, roots: readonly string[], paths: ReadonlySet<string>) {
   const loaded = new Set<string>();
-  for (let next = preloads.flatMap((preload) => importedFile(preload, paths) ?? []); next.length > 0; ) {
+  for (let next = [...roots]; next.length > 0; ) {
     for (const file of next) loaded.add(file);
-    const read = (file: string) => git(["show", `${rev}:${file}`]).pipe(Effect.map((text) => importsOf(file, text, paths)));
+    const read = (file: string) =>
+      git(["show", `${rev}:${file}`]).pipe(
+        Effect.map((text) => importsOf(file, text, paths)),
+        Effect.catchTag("GitFailure", (): Effect.Effect<readonly string[]> => Effect.succeed([])),
+      );
     const imported = (yield* Effect.forEach(next, read, { concurrency: 16 })).flat();
     next = [...new Set(imported)].filter((file) => !loaded.has(file));
   }
   return loaded;
 });
 
-const readTestTree = Effect.fn("readTestTree")(function* (paths: Iterable<string>) {
+const loadedByPreloads = Effect.fn("loadedByPreloads")(function* (rev: string, preloads: readonly string[], paths: ReadonlySet<string>) {
+  return yield* transitivelyImported(rev, preloads.flatMap((preload) => importedFile(preload, paths)), paths);
+});
+
+const readFiles = Effect.fn("readFiles")(function* (files: readonly string[]) {
   const fs = yield* FileSystem.FileSystem;
-  const files = [...paths].filter((path) => path.startsWith(TEST_TREE) && READ_FILE.test(path));
   const read = (file: string) => fs.readFileString(file).pipe(Effect.map((text) => [file, text] as const));
   return new Map(yield* Effect.forEach(files, read, { concurrency: 16 }));
 });
 
+const readTestTree = Effect.fn("readTestTree")(function* (paths: Iterable<string>) {
+  return yield* readFiles([...paths].filter((path) => path.startsWith(TEST_TREE) && READ_FILE.test(path)));
+});
+
+const GRAPH_FILE = /\.(?:tsx?|mts|cts|jsx?|mjs|cjs)$/;
+
+const readImportGraph = Effect.fn("readImportGraph")(function* (paths: Iterable<string>) {
+  return yield* readFiles([...paths].filter((path) => GRAPH_FILE.test(path)));
+});
+
 const loadBaseline = Effect.fn("loadBaseline")(function* (report: string | undefined, tests: ReadonlySet<string>) {
   const fs = yield* FileSystem.FileSystem;
   if (report === undefined || !(yield* fs.exists(report))) {
@@ -308,6 +240,29 @@ const unitReaders = Effect.fn("unitReaders")(function* (picked: Picked, { base,
   return readers;
 });
 
+export type Staleness = { readonly paths: ReadonlySet<string>; readonly preload: string | undefined; readonly stale: readonly string[]; readonly config: ReadonlySet<string> };
+
+export const stalenessSince = Effect.fn("stalenessSince")(function* (base: string, head: string) {
+  const picked = pickFromDiff(yield* changedPaths(base, head, []), () => false);
+  const atBase = new Set(yield* pathsAt(base, []));
+  const atHead = new Set(yield* pathsAt(head, []));
+  const preloads = { atBase: yield* preloadsAt(base, atBase), atHead: yield* preloadsAt(head, atHead) };
+  const loaded = new Set([...(yield* loadedByPreloads(head, preloads.atHead, atHead)), ...(yield* loadedByPreloads(base, preloads.atBase, atBase))]);
+  const preload = preloadChange(picked.paths, preloads, loaded);
+  const active = { atBase: STRYKER_CONFIGS.find((name) => atBase.has(name)), atHead: STRYKER_CONFIGS.find((name) => atHead.has(name)) };
+  const config = new Set([
+    ...(yield* transitivelyImported(head, active.atHead === undefined ? [] : [active.atHead], atHead)),
+    ...(yield* transitivelyImported(base, active.atBase === undefined ? [] : [active.atBase], atBase)),
+  ]);
+  if (preload !== undefined) return { paths: picked.paths, preload, stale: [], config };
+  if (picked.paths.size === 0) return { paths: picked.paths, preload: undefined, stale: [], config };
+  const readers = [...readersOf(yield* readImportGraph(atHead), [...picked.paths])]
+    .filter(([reader]) => isUnitTest(reader))
+    .map(([reader]) => reader);
+  const stale = [...new Set([...[...picked.paths].filter(isUnitTest), ...readers])].toSorted();
+  return { paths: picked.paths, preload: undefined, stale, config };
+});
+
 // An absent coverage edge holds only for a test whose merge-base source is the one the report ran.
 const staleIn = Effect.fn("staleIn")(function* (baseline: Baseline, tests: readonly string[], base: string) {
   const recorded = new Map(Object.entries(baseline.testFiles).map(([file, { source }]) => [file, source]));