@avi2dg/checks 0.51.0 → 0.52.1

package/src/docs/doc-versions.ts

@@ -0,0 +1,137 @@
+import { Effect, Option, Schema } from "effect";
+import { git } from "../core/git.ts";
+import { PACKAGE_MANIFEST } from "./doc-references.ts";
+import { scanMarkdown, type MarkdownLine } from "./prose-matchers.ts";
+
+type Pin = { readonly name: string | undefined; readonly version: string; readonly holder: string };
+
+const BUN_VERSION = ".bun-version";
+
+const Group = Schema.optionalKey(Schema.Record(Schema.String, Schema.String));
+const Manifest = Schema.Struct({
+  version: Schema.optionalKey(Schema.String),
+  packageManager: Schema.optionalKey(Schema.String),
+  engines: Group,
+  dependencies: Group,
+  devDependencies: Group,
+  peerDependencies: Group,
+  optionalDependencies: Group,
+});
+const decodeManifest = Schema.decodeUnknownOption(Schema.fromJsonString(Manifest));
+const NO_MANIFEST: typeof Manifest.Type = {};
+
+const VERSION = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/;
+const ONE_VERSION = new RegExp(String.raw`^[\^~=v]?(${VERSION.source})$`);
+const VERSIONS = new RegExp(VERSION.source, "g");
+
+function namedPins(group: Readonly<Record<string, string>> | undefined): readonly Pin[] {
+  return Object.entries(group ?? {}).flatMap(([name, range]) => {
+    const version = ONE_VERSION.exec(range.trim())?.[1];
+    return version === undefined ? [] : [{ name, version, holder: PACKAGE_MANIFEST }];
+  });
+}
+
+function barePins(value: string | undefined, holder: string): readonly Pin[] {
+  return [...(value ?? "").matchAll(VERSIONS)].map(([version]) => ({ name: undefined, version, holder }));
+}
+
+export function pinsOf(manifest: string, bunVersion: string): readonly Pin[] {
+  const { version, packageManager, engines = {}, dependencies, devDependencies, peerDependencies, optionalDependencies } = Option.getOrElse(
+    decodeManifest(manifest),
+    () => NO_MANIFEST,
+  );
+  const pins = [
+    ...[dependencies, devDependencies, peerDependencies, optionalDependencies].flatMap(namedPins),
+    ...[version, packageManager, ...Object.values(engines)].flatMap((value) => barePins(value, PACKAGE_MANIFEST)),
+    ...barePins(bunVersion, BUN_VERSION),
+  ];
+  return pins.filter((pin, index) => pins.findIndex((other) => other.name === pin.name && other.version === pin.version) === index);
+}
+
+function escaped(text: string): string {
+  return text.replaceAll(/[.*+?^${}()|[\]\\/]/g, String.raw`\$&`);
+}
+
+// A longer version that only opens with the pin, as 1.2.30 or 1.2.3-beta, is another version.
+const VERSION_END = String.raw`(?![\w-]|\.\d)`;
+
+function patternOf({ name, version }: Pin): RegExp {
+  const written =
+    name === undefined ? String.raw`(?<![\w.+-])v?${escaped(version)}` : String.raw`(?<![\w@/.-])${escaped(name)}@[\^~]?${escaped(version)}`;
+  return new RegExp(written + VERSION_END, "g");
+}
+
+const GENERATED_OPEN = /^\s*<!-- generated ([\w-]+):/;
+const GENERATED_CLOSE = /^\s*<!-- end generated ([\w-]+) -->/;
+
+function handWritten(lines: readonly MarkdownLine[]): readonly MarkdownLine[] {
+  const exempt = new Set<number>();
+  let at = 0;
+  while (at < lines.length) {
+    const opening = lines[at]?.kind === "code" ? null : GENERATED_OPEN.exec(lines[at]?.raw ?? "");
+    if (opening === null) {
+      at += 1;
+      continue;
+    }
+    const closeAt = lines.findIndex(
+      (line, index) => index > at && line.kind !== "code" && GENERATED_CLOSE.exec(line.raw)?.[1] === opening[1],
+    );
+    if (closeAt < 0) {
+      at += 1;
+      continue;
+    }
+    for (let index = at; index <= closeAt; index += 1) exempt.add(index);
+    at = closeAt + 1;
+  }
+  return lines.filter((_, index) => !exempt.has(index));
+}
+
+type Copy = { readonly at: number; readonly end: number; readonly pin: Pin; readonly written: string };
+
+function namePresent(raw: string, name: string): boolean {
+  return new RegExp(String.raw`(?<![\w@/.-])${escaped(name)}(?![\w/.-])`, "i").test(raw);
+}
+
+function barePatternFor(version: string): RegExp {
+  return new RegExp(String.raw`(?<![\w.+-])v?${escaped(version)}` + VERSION_END, "g");
+}
+
+// A bare pin inside a named copy, as 1.2.3 in zod@1.2.3, is the same copy.
+function copiesIn(raw: string, pins: readonly Pin[]): readonly Copy[] {
+  const found: Copy[] = [];
+  for (const pin of pins) {
+    for (const match of raw.matchAll(patternOf(pin))) {
+      const at = match.index;
+      found.push({ at, end: at + match[0].length, pin, written: match[0] });
+    }
+    if (pin.name !== undefined && namePresent(raw, pin.name)) {
+      for (const match of raw.matchAll(barePatternFor(pin.version))) {
+        const at = match.index;
+        found.push({ at, end: at + match[0].length, pin, written: match[0] });
+      }
+    }
+  }
+  const installed = found.filter((copy) => copy.written.includes("@"));
+  return found
+    .filter((copy) => copy.written.includes("@") || !installed.some(({ at, end }) => copy.at >= at && copy.end <= end))
+    .toSorted((a, b) => a.at - b.at);
+}
+
+export function versionFindings(text: string, pins: readonly Pin[], within?: ReadonlySet<number>): readonly { readonly line: number; readonly message: string }[] {
+  if (pins.length === 0) return [];
+  return handWritten(scanMarkdown(text))
+    .filter(({ line }) => within === undefined || within.has(line))
+    .flatMap(({ line, raw }) =>
+      copiesIn(raw, pins).map(({ written, pin }) => ({
+        line,
+        message: `carries \`${written}\`, a version ${pin.holder} pins. Name ${pin.holder} instead, or let a build write the line between generated markers`,
+      })),
+    );
+}
+
+const readAt = (root: string, head: string, path: string) =>
+  git(["show", `${head}:${path}`], root).pipe(Effect.catchTag("GitFailure", () => Effect.succeed("")));
+
+export const pinsAt = Effect.fn("pinsAt")(function* (root: string, head: string) {
+  return pinsOf(yield* readAt(root, head, PACKAGE_MANIFEST), yield* readAt(root, head, BUN_VERSION));
+});

package/src/docs/docs.ts

@@ -4,6 +4,7 @@ import { ceilingFinding, entryFindings, isAgentFile, maintainingFinding } from "
 import { rootsOf, snapshotOf, unresolvedIn, type Judging, type Unresolved } from "./doc-references.ts";
 import { ADR_DIRECTORY, judge, placementOf, placementProblem, recordsOf, speaksToConsumers, type Placement, type Records } from "./doc-rules.ts";
 import { vanishedNames } from "./doc-names.ts";
+import { pinsAt, versionFindings } from "./doc-versions.ts";
 import { readTexts, snapshotAt, stillMissing } from "./doc-snapshot.ts";
 import { changedLines, changedPaths, git, pathsAt, rangeEnds, refArgs } from "../core/git.ts";
 import { runMain } from "../core/main.ts";
@@ -107,6 +108,10 @@ const runDocs = Effect.fn("runDocs")(function* (root: string, base: string, head
   const prose = edited.flatMap(({ path, reader }) =>
     proseFindings(text(path), reader, changed.get(path)).map(({ line, message }) => ({ path, line, message })),
   );
+  const pins = yield* pinsAt(root, head);
+  const versions = edited.flatMap(({ path }) =>
+    versionFindings(text(path), pins, changed.get(path)).map(({ line, message }) => ({ path, line, message })),
+  );
   const sentenceAdvisory = edited
     .flatMap(({ path }) => longSentences(text(path), changed.get(path)).map(({ line, message }) => ({ path, line, message })))
     .toSorted(inPathOrder);
@@ -132,6 +137,7 @@ const runDocs = Effect.fn("runDocs")(function* (root: string, base: string, head
     findings: [
       ...templated.filter((finding) => touched.has(finding.path)),
       ...prose,
+      ...versions,
       ...references.failing,
       ...vanished,
       ...shapes,
@@ -153,6 +159,7 @@ export function report({ held, edited, named, agents, findings, advisory, senten
       ? [
           `${NAME}: ${held.length} doc file(s) the range touches hold to their templates`,
           `${NAME}: ${edited.lines} line(s) the range adds or edits in ${edited.docs} living doc(s) or agent file(s) hold to the prose rules`,
+          `${NAME}: no line the range adds or edits copies a version package.json or .bun-version pins`,
           `${NAME}: the range breaks no path, link or command the ${named} living doc(s) or agent file(s) name`,
           `${NAME}: the ${agents} agent file(s) hold to the ceiling, and every entry names a tracked path, a link or a command`,
         ]

package/src/quality/comment-matchers.ts

@@ -274,7 +274,7 @@ const CHECKS: readonly Check[] = [
       `carries the machine-read directive \`${match}\`. Fix what the tool is reporting, or stop running the tool on this file`,
   },
   {
-    find: /\bADR[\s-]?\d+|\bdocs\/adr\b|\bRFC[\s-]?\d+|(?:^|[\s(["'`])#\d+\b|[\w.-]+\/[\w.-]+#\d+|\/(?:issues|pull)\/\d+/i,
+    find: /\bADR[\s-]?\d+|\bdocs\/adr\b|(?:^|[\s(["'`])#\d+\b|[\w.-]+\/[\w.-]+#\d+|\/(?:issues|pull)\/\d+/i,
     refusal: (match) =>
       `points at a record or a ticket (${JSON.stringify(match.trim())}). Drop the pointer: a record is reached by searching docs/adr, and the story of the change goes in the commit message`,
   },

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

@@ -1,7 +1,7 @@
-import { Console, Effect, FileSystem, Schema } from "effect";
+import { Clock, Config, Console, Effect, FileSystem, Option, Schema } from "effect";
 import { ChildProcessSpawner } from "effect/process";
 import { collect } from "../core/git.ts";
-import { isRecord, withoutStale } from "./mutation-baseline-saved.ts";
+import { withoutStale } from "./mutation-baseline-saved.ts";
 import { STRYKER_CONFIGS, stalenessSince } from "./mutation-scope.ts";
 
 export class BaselineFailure extends Schema.TaggedError<BaselineFailure>()("BaselineFailure", {
@@ -17,49 +17,18 @@ export const gh = Effect.fn("gh")(function* (args: readonly string[]) {
 
 const FULL_CONFIGS = [...STRYKER_CONFIGS, "stryker.preset.js", "bun.lock", ".bun-version"];
 
-const parsedJson = (text: string) =>
-  Effect.try({
-    try: (): unknown => JSON.parse(text),
-    catch: () => new BaselineFailure({ message: "package.json is not JSON" }),
-  });
+const REFRESH_DAYS = 28;
+const DAY_MS = 86_400_000;
 
-const withoutVersion = (text: string) =>
-  parsedJson(text).pipe(
-    Effect.map((parsed) => {
-      if (!isRecord(parsed)) return undefined;
-      return JSON.stringify(Object.fromEntries(Object.entries(parsed).filter(([key]) => key !== "version")));
-    }),
-    Effect.catchTag("BaselineFailure", () => Effect.succeed(undefined)),
-  );
+const refreshWindow = (time: number): number => Math.floor(time / (REFRESH_DAYS * DAY_MS));
 
-const patchedPaths = (text: string | undefined): Effect.Effect<readonly string[], BaselineFailure> => {
-  if (text === undefined) return Effect.succeed([]);
-  return parsedJson(text).pipe(
-    Effect.map((parsed) => {
-      if (!isRecord(parsed)) return [];
-      const patched = parsed["patchedDependencies"];
-      if (!isRecord(patched)) return [];
-      return Object.values(patched).flatMap((value) => (typeof value === "string" ? [value.replace(/^\.\//, "")] : []));
-    }),
-    Effect.catchTag("BaselineFailure", (): Effect.Effect<readonly string[]> => Effect.succeed([])),
-  );
-};
+// Each full run reuses what the run before it restored, so a cap on the restored run's age alone caps nothing.
+// Windows fixed from the epoch cap the whole chain: every state in a window was built from runs in that window.
+export function inRefreshWindow(createdAt: string, now: number): boolean {
+  return refreshWindow(Date.parse(createdAt)) === refreshWindow(now);
+}
 
-const shownAt = (rev: string, path: string) =>
-  collect("git", ["show", `${rev}:${path}`]).pipe(
-    Effect.map(({ stdout, exitCode }) => (exitCode === ChildProcessSpawner.ExitCode(0) ? stdout : undefined)),
-    Effect.mapError((cause) => new BaselineFailure({ message: cause.message })),
-    Effect.catchTag("BaselineFailure", () => Effect.succeed(undefined)),
-  );
-
-const packageInputs = Effect.fn("packageInputs")(function* (base: string, head: string, paths: ReadonlySet<string>) {
-  const inputs = new Set<string>();
-  const [before, after] = yield* Effect.all([shownAt(base, "package.json"), shownAt(head, "package.json")]);
-  if (paths.has("package.json") && (before === undefined || after === undefined || (yield* withoutVersion(before)) !== (yield* withoutVersion(after))))
-    inputs.add("package.json");
-  for (const text of [before, after]) for (const path of yield* patchedPaths(text)) if (paths.has(path)) inputs.add(path);
-  return inputs;
-});
+export type FullRun = { readonly databaseId: number; readonly createdAt: string };
 
 const decodeHeadSha = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ headSha: Schema.String })));
 
@@ -67,16 +36,23 @@ const viewedHead = Effect.fn("viewedHead")(function* (run: number) {
   return (yield* gh(["run", "view", String(run), "--json", "headSha"]).pipe(Effect.flatMap(decodeHeadSha))).headSha;
 });
 
-export const pruneFullState = Effect.fn("pruneFullState")(function* (run: number, state: string) {
+export const pruneFullState = Effect.fn("pruneFullState")(function* (run: FullRun, state: string) {
   const fs = yield* FileSystem.FileSystem;
   if (!(yield* fs.exists(state))) return;
-  const base = yield* viewedHead(run);
+  const override = yield* Config.Int("CHECKS_MUTATION_BASELINE_NOW_MS").pipe(Config.option);
+  let now = yield* Clock.currentTimeMillis;
+  if (Option.isSome(override)) now = override.value;
+  if (!inRefreshWindow(run.createdAt, now)) {
+    yield* fs.remove(state);
+    yield* Console.log(`mutation-baseline: dropped the restored full state, run ${run.databaseId} started before the current ${REFRESH_DAYS}-day refresh window`);
+    return;
+  }
+  const base = yield* viewedHead(run.databaseId);
   const { paths, preload, stale, config } = yield* stalenessSince(base, "HEAD");
-  const inputs = yield* packageInputs(base, "HEAD", paths);
-  const changed = [...paths].filter((path) => FULL_CONFIGS.includes(path) || inputs.has(path) || config.has(path)).toSorted();
+  const changed = [...paths].filter((path) => FULL_CONFIGS.includes(path) || config.has(path)).toSorted();
   if (changed.length > 0 || preload !== undefined) {
     yield* fs.remove(state);
-    yield* Console.log(`mutation-baseline: dropped the restored full state, ${preload ?? changed.join(" ")} changed since run ${run}`);
+    yield* Console.log(`mutation-baseline: dropped the restored full state, ${preload ?? changed.join(" ")} changed since run ${run.databaseId}`);
     return;
   }
   const text = yield* fs.readFileString(state);

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

@@ -16,7 +16,7 @@ const SavedFiles = Schema.Struct({ [INCREMENTAL]: Schema.Unknown, [REPORT]: Sche
 export type SavedFiles = typeof SavedFiles.Type;
 const decodeSavedFiles = Schema.decodeUnknownEffect(Schema.fromJsonString(SavedFiles));
 
-export const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> => typeof value === "object" && value !== null && !Array.isArray(value);
 
 const withoutReason = (mutant: unknown): unknown => (isRecord(mutant) ? Object.fromEntries(Object.entries(mutant).filter(([key]) => key !== "statusReason")) : mutant);
 

package/src/testing/mutation-baseline.ts

@@ -46,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"))));
@@ -61,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.
@@ -108,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)));
@@ -341,10 +343,10 @@ function parsed([first, ...rest]: readonly string[]): Command | undefined {
   return restoreRequest(first, report, extra);
 }
 
-const restoredRun = Effect.fn("restoredRun")(function* (run: number, name: string, root: Option.Option<string>, shelf: Option.Option<string>, request: Request) {
-  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.isNone(artifact) || !(yield* restoredFrom(run, artifact.value, root, request))) return false;
+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;

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

@@ -18,20 +18,11 @@ export function resolved(directory: string, spec: string): string {
 }
 
 // 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>, mains: ReadonlyMap<string, string> = new Map()): readonly string[] {
-  const probe = (target: string): readonly string[] => {
-    const bare = target.replace(/\.m?js$/, "");
-    return [target, ...CANDIDATE_EXTENSIONS.map((extension) => bare + extension)].filter((file) => files.has(file));
-  };
-  const index = (target: string): readonly string[] =>
-    CANDIDATE_EXTENSIONS.map((extension) => `${target}/index${extension}`).filter((file) => files.has(file));
-  const direct = probe(path);
+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;
-  const main = mains.get(path);
-  if (main === undefined) return index(path);
-  const manifest = path === "" ? "package.json" : `${path}/package.json`;
-  if (main === manifest) return [manifest, ...index(path)];
-  return [manifest, ...probe(main), ...index(main), ...index(path)];
+  return CANDIDATE_EXTENSIONS.map((extension) => `${path}/index${extension}`).filter((file) => files.has(file));
 }
 
 function fixtureNeedles(changed: readonly string[]): readonly Needle[] {
@@ -54,13 +45,13 @@ function mentions(line: string, { text, kind }: Needle): boolean {
 
 type Edge = { readonly importer: string; readonly imported: string };
 
-export function importsOf(file: string, text: string, files: ReadonlySet<string>, mains: ReadonlyMap<string, string> = new Map()): readonly 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, mains));
+  return [...text.matchAll(IMPORT)].flatMap(([, throughImport = "", throughRequire = ""]) => importedFile(resolved(directory, throughImport || throughRequire), files));
 }
 
-const edgesOf = (file: string, text: string, files: ReadonlySet<string>, mains: ReadonlyMap<string, string> = new Map()): readonly Edge[] =>
-  importsOf(file, text, files, mains).map((imported) => ({ importer: file, imported }));
+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;
@@ -85,7 +76,7 @@ function spread(reached: Map<string, string>, edges: readonly Edge[]): void {
 }
 
 // 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[], mains: ReadonlyMap<string, string> = new Map()): Map<string, string> {
+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) {
@@ -93,6 +84,6 @@ export function readersOf(sources: ReadonlyMap<string, string>, changed: readonl
     if (fixture !== undefined) reached.set(file, fixture);
   }
   const files = new Set([...sources.keys(), ...changed]);
-  spread(reached, [...sources].flatMap(([file, text]) => edgesOf(file, text, files, mains)));
+  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,7 +3,6 @@ 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 { isRecord } from "./mutation-baseline-saved.ts";
 import { importedFile, importsOf, readersOf, resolved, TEST_TREE } from "./mutation-scope-graph.ts";
 
 const NAME = "mutation-scope";
@@ -180,13 +179,13 @@ const preloadsAt = Effect.fn("preloadsAt")(function* (rev: string, paths: Readon
   return (typeof preload === "string" ? [preload] : preload).map((entry) => resolved("", entry));
 });
 
-const transitivelyImported = Effect.fn("transitivelyImported")(function* (rev: string, roots: readonly string[], paths: ReadonlySet<string>, mains: ReadonlyMap<string, string> = new Map()) {
+const transitivelyImported = Effect.fn("transitivelyImported")(function* (rev: string, roots: readonly string[], paths: ReadonlySet<string>) {
   const loaded = new Set<string>();
   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, mains)),
+        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();
@@ -195,39 +194,8 @@ const transitivelyImported = Effect.fn("transitivelyImported")(function* (rev: s
   return loaded;
 });
 
-const loadedByPreloads = Effect.fn("loadedByPreloads")(function* (rev: string, preloads: readonly string[], paths: ReadonlySet<string>, mains: ReadonlyMap<string, string> = new Map()) {
-  return yield* transitivelyImported(rev, preloads.flatMap((preload) => importedFile(preload, paths, mains)), paths, mains);
-});
-
-const mainOf = (text: string) =>
-  Effect.try({
-    try: (): unknown => JSON.parse(text),
-    catch: () => new ScopeError({ message: "package.json does not parse as JSON holding a main entry" }),
-  }).pipe(
-    Effect.map((parsed) => {
-      if (!isRecord(parsed)) return undefined;
-      const main = parsed["main"];
-      return typeof main === "string" && main.trim() !== "" ? main : undefined;
-    }),
-    Effect.catchTag("ScopeError", () => Effect.succeed(undefined)),
-  );
-
-const readMains = Effect.fn("readMains")(function* (rev: string, paths: ReadonlySet<string>) {
-  const packages = [...paths].filter((path) => path === "package.json" || path.endsWith("/package.json"));
-  const entries = yield* Effect.forEach(
-    packages,
-    (file) => git(["show", `${rev}:${file}`]).pipe(Effect.map((text): readonly [string, string] => [file, text]), Effect.catchTag("GitFailure", () => Effect.succeed(undefined))),
-    { concurrency: 16 },
-  );
-  const mains = new Map<string, string>();
-  for (const entry of entries) {
-    if (entry === undefined) continue;
-    const [file, text] = entry;
-    const main = yield* mainOf(text);
-    const directory = file.includes("/") ? file.slice(0, file.lastIndexOf("/")) : "";
-    mains.set(directory, main === undefined ? file : resolved(directory, main));
-  }
-  return mains;
+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[]) {
@@ -279,17 +247,16 @@ export const stalenessSince = Effect.fn("stalenessSince")(function* (base: strin
   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 mains = new Map([...(yield* readMains(base, atBase)), ...(yield* readMains(head, atHead))]);
-  const loaded = new Set([...(yield* loadedByPreloads(head, preloads.atHead, atHead, mains)), ...(yield* loadedByPreloads(base, preloads.atBase, atBase, mains))]);
+  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, mains)),
-    ...(yield* transitivelyImported(base, active.atBase === undefined ? [] : [active.atBase], atBase, mains)),
+    ...(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], mains)]
+  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();