waterplane 0.0.1 → 0.1.6

package/tools/repohealth/metrics/tripwires.mjs

@@ -0,0 +1,258 @@
+/**
+ * Tripwires — the facts that are events, and must never become a line on a
+ * plot.
+ *
+ * ── Why these are not metrics ───────────────────────────────────────────────
+ *
+ * Everything else in this series is a value read against its own past: a
+ * percentile within a trailing window and the sign of a slope. That reading is
+ * the right one for "how big are the files" and the wrong one for "a file went
+ * past two thousand lines". A threshold crossing happens once. Plotted, it is
+ * a step that stays high forever and drags every subsequent percentile with
+ * it; ranked, it is indistinguishable from the file sitting still. Said once,
+ * on the day it happened, with the number it crossed, it is a sentence
+ * somebody acts on.
+ *
+ * So a tripwire is a `{kind, subject, detail}` on the row of the commit where
+ * it fired, `[]` on every other row, and nothing downstream is allowed to
+ * average them.
+ *
+ * ── The one thing these two have in common ──────────────────────────────────
+ *
+ * Each is a TRANSITION, not a state, and telling the two apart is the whole
+ * difficulty. A file that has been 2,400 lines for three months is not news
+ * every day for three months. `@ts-ignore` appearing for the first time is
+ * news exactly once; the seventh one is not. So each needs to know what was
+ * true at the previous commit, and `Row`'s measured fields do not carry it:
+ * `size` has a p95 and a max, not the per-file line counts, and `hatches` has
+ * today's totals, not the first day each kind was non-zero.
+ *
+ * ── Why the carried state is IN THE ROW ─────────────────────────────────────
+ *
+ * It used to be a module-level `Map` keyed by sha, on the argument that a
+ * backfill walks the chain in order and a cache miss degrades to baseline, and
+ * that a later full backfill would correct anything a miss had cost. Both
+ * halves of that are false in the one way that matters.
+ *
+ * A daily `update` is a FRESH PROCESS. The memo is empty, the previous commit
+ * was measured yesterday by a process that has exited, so every daily run
+ * looked up a sha it had never walked, took the baseline branch, and wrote
+ * `[]`. And the store is append-only: `missingShas` never recomputes a sha
+ * that already has a row, so that `[]` is what the series says about that
+ * commit forever. The correcting backfill the header promised cannot happen.
+ * Reproduced on this repo's own series: sha `7aaee35` (2026-08-16) recorded 8
+ * tripwires during the in-order backfill, and recomputing it in a fresh
+ * process returned 0. With the state in the row, the same sha recomputed in a
+ * fresh process from a `prevRow` read off disk returns exactly what the
+ * in-order walk recorded for it.
+ *
+ * So the state travels in the row, as `tripwireState`, and is read back off
+ * `prevRow` — which the caller has in its hand whether it is replaying 157
+ * commits or appending one. It is deliberately the SMALLEST thing that answers
+ * "what changed": the paths already over the limit, the line counts of the
+ * files big enough to cross it next, and which hatch kinds have ever been
+ * non-zero. Every list is sorted, because a row is compared to a committed
+ * fixture with `deepEqual` and `Set` iteration order is insertion order, not a
+ * promise.
+ *
+ * A row with no `tripwireState` — the first commit, or a row written before
+ * this field existed — is a baseline and fires nothing. That rule is the
+ * repo's: **never a guess.** A tripwire that fires because the tool forgot
+ * what yesterday looked like is worse than one that stays quiet, because the
+ * quiet one is corrected by a re-cut history and the loud one is acted on.
+ *
+ * ── Why a rename reads as a new file ────────────────────────────────────────
+ *
+ * `git.mjs` asks for numstat with `diff.renames=false`, so a rename is a
+ * delete and an add and the paths in `Commit.filesTouched` stay literal. That
+ * is the right trade for every other metric in the series — a renamed file's
+ * co-change and re-touch history should not silently follow it to a new name —
+ * and it means this module cannot tell `workingLine.ts` → `working.ts`
+ * (2026-09-14, in this history) from a file written from scratch. It is
+ * accepted rather than fixed: inferring a rename from "a path vanished and a
+ * path of about the same size appeared" is a guess, and this module does not
+ * guess. What was fixed is the sentence. A crossing with no previous reading
+ * no longer claims the file was "first seen at this size" — it says what is
+ * actually known, which is that the path was not among the previous commit's
+ * big files: new, renamed, or simply under half the limit a commit ago.
+ *
+ * ── Why the dead export is no longer here ───────────────────────────────────
+ *
+ * There was a third tripwire: a file's first export that no other blob in the
+ * tree named. It was a state reported as an event, and what it actually
+ * detected was a module being BORN before its caller landed — which on this
+ * repo's shared working tree is most of a normal day. Measured over the same
+ * 157 commits: it fired 126 times, which is 126 of the 137 tripwires the whole
+ * series produced, naming 277 exports; 100 of those 277 were named by a blob
+ * in the tree by the END OF THE SAME DAY, and 8 were never dead at all, just
+ * invisible to a tokenizer that stopped reading at the first backtick. The
+ * other two tripwires fired 11 times between them in the same history.
+ *
+ * The state now lives in the row as `deadExports` (`dups.mjs` owns it, because
+ * it owns the identifier machinery), and the event is the one comparison the
+ * old header claimed and the old code did not make: a name another blob named
+ * on the PREVIOUS day-row, whose file still exists, that no blob names today.
+ * That is an orphaning, it needs no threshold, and it cannot fire on a file's
+ * first day.
+ *
+ * Nothing here reads a file, runs git, parses TypeScript, or calls a model.
+ * Everything is in the snapshot and in the previous row.
+ */
+
+// ── formatting ──────────────────────────────────────────────────────────────
+
+/**
+ * Thousands separators, written out rather than `toLocaleString`: this string
+ * goes into a committed fixture, and `toLocaleString` is a different string on
+ * a machine with a different default locale.
+ */
+function n(x) {
+  const s = String(x);
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (i > 0 && (s.length - i) % 3 === 0) out += ",";
+    out += s[i];
+  }
+  return out;
+}
+
+// ── escape hatches ──────────────────────────────────────────────────────────
+
+/** Pattern source -> compiled pair. The sources are the active packs', merged
+ *  into `HATCH_KINDS` by `census.mjs`. */
+const HATCH_RE = new Map();
+function hatchRe(src) {
+  let pair = HATCH_RE.get(src);
+  if (!pair) {
+    pair = { one: new RegExp(src), all: new RegExp(src, "g") };
+    HATCH_RE.set(src, pair);
+  }
+  return pair;
+}
+
+/**
+ * OCCURRENCES of one hatch kind across the tree's source files.
+ *
+ * Counted the way `constants.mjs` pins and every pack writes its patterns for
+ * — `matchAll`, not matching lines, not substrings — because this number
+ * appears in a sentence
+ * next to the zero it replaced, and a number counted two ways in two modules
+ * is how a report contradicts itself.
+ */
+function hatchCount(files, src) {
+  const { all } = hatchRe(src);
+  let total = 0;
+  for (const f of files) for (const _ of f.text.matchAll(all)) total++;
+  return total;
+}
+
+function hatchPresent(files, src) {
+  const { one } = hatchRe(src);
+  for (const f of files) if (one.test(f.text)) return true;
+  return false;
+}
+
+// ── the metric ──────────────────────────────────────────────────────────────
+
+/**
+ * Everything that changed state at this commit and is worth one sentence, and
+ * the state the NEXT commit needs in order to ask the same question.
+ *
+ * The caller writes both onto the row: `tripwires` and `tripwireState`. A
+ * caller that keeps only the first has a series in which nothing can ever fire
+ * again after the process that wrote it exits — which is the bug this shape
+ * exists to make impossible to reintroduce quietly.
+ *
+ * @param {import("../types.mjs").Snapshot} snapshot
+ * @param {import("../types.mjs").History} _history
+ * @param {number} index                 Position in the first-parent walk.
+ * @param {typeof import("../constants.mjs").PREREG} prereg
+ * @param {import("../types.mjs").Row|null} prevRow
+ * @returns {{value: {kind: string, subject: string, detail: string}[],
+ *            state: {hatchSeen: string[], near: {loc: number, path: string}[], overLimit: string[]}}}
+ */
+export function measureTripwires(snapshot, _history, index, prereg, prevRow) {
+  const limit = prereg.LINES_TRIPWIRE;
+  const nearLimit = Math.floor(limit / 2);
+
+  // ── what is true now ──
+  const overLimit = [];
+  const near = [];
+  for (const f of snapshot.files) {
+    if (f.loc >= limit) overLimit.push(f.path);
+    // Only the big files' lengths are carried forward: the state exists to
+    // print "up from 1,974", and nothing under half the limit can reach it in
+    // one commit without that commit being the whole story anyway. It is also
+    // what keeps the state small enough to sit in every row — the full set of
+    // per-file line counts would be 325 entries a commit.
+    if (f.loc >= nearLimit) near.push({ loc: f.loc, path: f.path });
+  }
+  const hatchNow = [];
+  for (const [kind, src] of Object.entries(prereg.HATCH_KINDS)) {
+    if (hatchPresent(snapshot.files, src)) hatchNow.push(kind);
+  }
+
+  // `snapshot.files` is sorted by path, so `overLimit` and `near` already are;
+  // sorting again is cheap and says the ordering is a promise, not a habit.
+  overLimit.sort();
+  near.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  hatchNow.sort();
+
+  // A state that is missing a list is a state this code cannot read — an older
+  // row, or a truncated write. Same rule as no state at all: baseline, never a
+  // guess reconstructed from the half that is there.
+  const carried = prevRow ? prevRow.tripwireState : null;
+  const prev =
+    carried && Array.isArray(carried.overLimit) && Array.isArray(carried.near) && Array.isArray(carried.hatchSeen)
+      ? carried
+      : null;
+
+  const state = {
+    // Cumulative: once a kind has been non-zero it can never "appear" again.
+    hatchSeen: prev ? [...new Set([...prev.hatchSeen, ...hatchNow])].sort() : hatchNow,
+    near,
+    overLimit,
+  };
+
+  // Baseline. See the header: no chain, no claim. At `index === 0` a
+  // 2,400-line file is a state, not a crossing, and `@ts-ignore` present from
+  // the start never "appeared".
+  if (!prev || index === 0) return { state, value: [] };
+
+  const wasOver = new Set(prev.overLimit);
+  const wasNear = new Map(prev.near.map((e) => [e.path, e.loc]));
+  const seen = new Set(prev.hatchSeen);
+  const fired = [];
+
+  // ── a file crossing the line limit, upward, once ──
+  const nowLoc = new Map(near.map((e) => [e.path, e.loc]));
+  for (const path of overLimit) {
+    if (wasOver.has(path)) continue; // a state, not a crossing
+    const now = nowLoc.get(path);
+    const before = wasNear.get(path);
+    const detail =
+      before === undefined
+        ? `${n(now)} lines, past the ${n(limit)}-line mark; the path carried no reading a commit ago — ` +
+          `under ${n(nearLimit)} lines, or new, or renamed`
+        : `${n(before)} → ${n(now)} lines, past the ${n(limit)}-line mark`;
+    fired.push({ kind: "file-crossed-lines", subject: path, detail });
+  }
+
+  // ── a kind of escape hatch that had never been used ──
+  for (const kind of hatchNow) {
+    if (seen.has(kind)) continue;
+    const count = hatchCount(snapshot.files, prereg.HATCH_KINDS[kind]);
+    fired.push({
+      kind: "hatch-kind-appeared",
+      subject: kind,
+      detail: `\`${prereg.HATCH_KINDS[kind]}\` went 0 → ${n(count)} occurrences; ${n(
+        hatchNow.length,
+      )} of ${n(Object.keys(prereg.HATCH_KINDS).length)} hatch kinds are now in use`,
+    });
+  }
+
+  // Fixed order, because a row is compared to a committed fixture with
+  // `deepEqual`.
+  fired.sort((a, b) => (a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : 0));
+  return { state, value: fired };
+}

package/tools/repohealth/metrics/untested.mjs

@@ -0,0 +1,308 @@
+/**
+ * Which modules no test reaches — as a LIST, not a ratio — and, beside it,
+ * which are reached only through another module.
+ *
+ * ── Named, reached, and why the headline is the second ──────────────────────
+ *
+ * A module is NAMED when a test's text references its path (the rule below).
+ * It is REACHED when a test imports it, or imports something that does, to
+ * any depth, by each language's own import syntax (a pack's `imports`).
+ * `value` is the modules that are neither; `unnamed` is the ones reached and
+ * never named.
+ *
+ * Naming alone was the headline until 2026-10-15, and in a repo that splits
+ * big files it measured the splitting: carving one named file into a dozen
+ * slices it imports added a dozen lines, every one of them run by the same
+ * tests as before. Here that read "854 of 1,655 modules, rising" over a
+ * window in which `App.tsx` was cut into 811 files under `core/` and
+ * `features/`, and 341 of the 854 were reached by a test's own imports.
+ * Reach is what a person asking "is this tested" means; naming is kept as the
+ * second list because "only ever exercised from a distance" is worth reading
+ * too, and it is not the same fact as "never run".
+ *
+ * Reach still promises less than coverage: an imported module is LOADED by a
+ * test, which says nothing about which of its branches ran. And only imports
+ * are edges — a module a test merely names (reads as text, spawns by path)
+ * counts as named, but its own imports are not followed from it, because
+ * `createOp.test.mjs` reading `./App.tsx` as a string would otherwise mark
+ * the whole phone reached. A pack with a mention rule and no import rule
+ * contributes no edges, so its modules are read on naming alone.
+ *
+ * ── Why a list and not a percentage ─────────────────────────────────────────
+ *
+ * "73% of modules are mentioned by a test" is a number that goes up when you
+ * add a tested feature and down when you add an untested one, and it is
+ * therefore mostly a plot of how fast the repo is growing. It also cannot be
+ * acted on: nobody can write a test for 27%. The list can be read, diffed, and
+ * closed one line at a time, and the interesting event — "a module that used
+ * to be named by a test no longer is" — is a line disappearing from it, which
+ * a ratio would hide behind two other modules arriving.
+ *
+ * The list is sorted, like everything else here, because the row is compared
+ * to a committed fixture with `deepEqual` and an unsorted list fails on
+ * nothing at all.
+ *
+ * ── What counts as "a test mentions it" ─────────────────────────────────────
+ *
+ * A PATH reference, never a bare identifier. `PREREG` spells out why, and it
+ * is the half of the definition that survives translation: `git`, `api`,
+ * `echo` and `context` are all module basenames here AND ordinary English in
+ * the prose of half these test files, so an identifier match would mark most
+ * of the tree tested on the strength of comments.
+ *
+ * What a reference LOOKS like is a language's business and lives in the pack.
+ * `packs/typescript.mjs`'s `mentions()` and `keysFor()` hold the accepted
+ * forms (`NAME.ts`, `NAME.tsx`, `NAME.js` for the host tests that import
+ * compiled output, or the closing quote of an extensionless specifier), the
+ * two boundaries that keep `.json` from marking `notify.ts` and
+ * `smartpickstore.js` from naming `store`, and the `src` → `dist` mirror. The
+ * whole argument for each of them moved there with the code; this module is
+ * what asks the question and what refuses to answer it when no active pack
+ * can.
+ *
+ * ── A language with no mention rule is an absence, never a list ────────────
+ *
+ * A pack declares `mentions`/`keysFor` or declares them `null`. Where NO
+ * active pack supplies them the metric is `{value: null, reason}`: "every
+ * module in this repo is untested" is what a Kotlin tree would otherwise
+ * report, on the strength of nothing having been read at all, and it is the
+ * single loudest wrong number this engine could print. Where SOME pack
+ * supplies them, the list covers the files that pack owns and silently covers
+ * no others — a file whose language cannot be read contributes no line in
+ * either direction, because it is not evidence.
+ *
+ * ── Why a bare basename is not enough (PREREG.UNTESTED_REQUIRE_DIR_SEGMENT) ──
+ *
+ * This matched on BASENAME alone and was wrong in both directions at once.
+ *
+ * It claimed coverage from strings that name no module. `"/api/repos"` marked
+ * `repos.ts` tested; `"/repo"` marked `wire/repo.ts`; `".claude/outbox"`
+ * marked `outbox.ts`; `".claude/outbox/link"` marked `link.ts`;
+ * `"packages/web"` marked `capture/web.ts`. Five modules at HEAD were
+ * "mentioned" by a URL or a directory literal.
+ *
+ * And it collided: 28 basenames exist more than once in this tree (`api`,
+ * and `index`, `settings`, `screenlog` three times each), so one test naming
+ * `git.js` marked every `git.ts` in every package — up to ~34 files falsely
+ * covered by 26 of those names.
+ *
+ * So a mention must carry the module's own DIRECTORY CONTEXT: the directory
+ * part of the reference, after the normalisation below, must be a suffix of
+ * the module's own directory. `web/src/link`, `packages/web/src/link.ts` and
+ * `./link` from a test inside `packages/web/src/` are all mentions of
+ * `packages/web/src/link.ts` and none of them is a mention of a `link.ts` in
+ * another package; a bare `link` is a mention of nothing.
+ *
+ * The three normalisations that make that rule true of the references a repo
+ * actually writes — a relative specifier joined to the file that wrote it,
+ * the compiled mirror counted as the module's own directory, a leading `/`
+ * read as repo-relative because that shape is a URL — are all statements
+ * about one language's import syntax, so they are the pack's and the
+ * reasoning for each moved there with the code. Every one of them is pure
+ * string work: nothing here or there resolves a module, reads a file, or
+ * needs a build.
+ *
+ * The rule still under-reports rather than over-reports: a reference whose
+ * directory context is genuinely ambiguous (`src/api.ts`, naming no package)
+ * marks both copies, and this row measures whether a test NAMES a module, not
+ * whether it exercises one. `App.tsx` and `main.tsx` are "mentioned" because
+ * `packages/web/src/createOp.test.mjs` `readFileSync`s `./App.tsx` and
+ * `scripts/e2e-gallery.mjs` reads `packages/web/src/main.tsx` — true, and a
+ * weaker claim than coverage. This row is evidence, not an accusation.
+ *
+ * ── Why the corpus is tokenised once ────────────────────────────────────────
+ *
+ * The obvious loop is 325 candidate regexes over ~100 test files, per commit,
+ * over 157 commits — hundreds of gigabytes scanned to answer a set-membership
+ * question. Instead every reference in the corpus is extracted in one pass
+ * into a Set of `dir/name` keys, and each candidate module asks the Set about
+ * the handful of keys its own path could answer to. Same answer, one scan.
+ */
+import { packFor, packsWith, reasonFor } from "./route.mjs";
+
+/**
+ * Every `dir/name` key one test corpus names, unioned over the active packs
+ * that have a rule for it.
+ *
+ * A union and not a per-language partition: a test written in one language
+ * can name a module written in another (a shell script or an e2e harness
+ * naming a source file by path), and a key is only ever a string. Two packs
+ * producing the same key is the same claim twice, which a Set already
+ * handles.
+ */
+function mentionsOf(tests, packs, requireDir) {
+  const out = new Set();
+  for (const t of tests) {
+    for (const p of packs) {
+      for (const key of p.pack.mentions(t.text, t.path ?? "", { requireDir })) out.add(key);
+    }
+  }
+  return out;
+}
+
+/**
+ * The keys one source file's imports name, memoised by blob.
+ *
+ * Reach reads EVERY source file's imports at every commit, where the mention
+ * corpus is only the tests, and over a backfill most of those blobs are the
+ * same bytes commit after commit. So the answer is kept under the blob oid —
+ * which names one set of bytes forever, the guarantee `lang/typescript-ast.mjs`
+ * keys its own memo on — plus the path (a relative specifier resolves against
+ * it), the pack and the rule. A file with no oid is read and not kept.
+ */
+const IMPORTS_MEMO = new Map();
+function importsOf(owner, file, requireDir) {
+  if (!file.oid) return owner.pack.imports(file.text, file.path, { requireDir });
+  const key = `${owner.name}\0${file.oid}\0${file.path}\0${requireDir ? 1 : 0}`;
+  let keys = IMPORTS_MEMO.get(key);
+  if (!keys) {
+    keys = [...owner.pack.imports(file.text, file.path, { requireDir })];
+    IMPORTS_MEMO.set(key, keys);
+  }
+  return keys;
+}
+
+/**
+ * Which readable modules a test REACHES: what a test file imports, then what
+ * those import, to the end — following each file's imports by the rule of the
+ * pack that owns that file, because an import statement is one language's
+ * syntax and a key is only ever compared as a string afterwards.
+ *
+ * Seeded from every file in the test corpus, helpers included: a fixture
+ * builder in `test/` that imports `../dist/x.js` is how half these suites
+ * reach the code, and it is in the corpus for exactly that reason.
+ *
+ * Mentions are deliberately NOT seeds. A module a test only names — reads as
+ * text, spawns by path — counts as tested on that name, as it always has, but
+ * its own imports are not followed from it: `createOp.test.mjs` reading
+ * `./App.tsx` would otherwise mark the whole phone reached.
+ *
+ * @param {{f: {path: string, oid?: string, text: string}, owner: object}[]} readable
+ * @returns {Set<string>} paths
+ */
+function reachOf(readable, tests, prereg, requireDir) {
+  const leaf = (k) => (requireDir ? k : k.slice(k.lastIndexOf("/") + 1));
+  /** key -> every readable module answering to it. Two modules on one key are
+   *  both reached, which is the ambiguity `mentions` already resolves the
+   *  same way (`src/api.ts` naming no package marks both copies). */
+  const byKey = new Map();
+  const byPath = new Map();
+  for (const r of readable) {
+    byPath.set(r.f.path, r);
+    for (const k of r.owner.pack.keysFor(r.f.path)) {
+      const key = leaf(k);
+      const at = byKey.get(key);
+      if (at) at.push(r.f.path);
+      else byKey.set(key, [r.f.path]);
+    }
+  }
+
+  const reached = new Set();
+  const queue = [];
+  const visit = (keys) => {
+    for (const key of keys) {
+      for (const p of byKey.get(key) ?? []) {
+        if (reached.has(p)) continue;
+        reached.add(p);
+        queue.push(p);
+      }
+    }
+  };
+  for (const t of tests) {
+    const owner = packFor(t.path ?? "", prereg);
+    if (owner && typeof owner.pack.imports === "function") visit(owner.pack.imports(t.text, t.path ?? "", { requireDir }));
+  }
+  while (queue.length) {
+    const r = byPath.get(queue.pop());
+    if (typeof r.owner.pack.imports === "function") visit(importsOf(r.owner, r.f, requireDir));
+  }
+  return reached;
+}
+
+/**
+ * @param {import("../types.mjs").Snapshot} snapshot
+ * @param {import("../types.mjs").History} history
+ * @param {number} index
+ * @param {import("../types.mjs").EffectivePrereg} prereg
+ * @returns {import("../types.mjs").Measured<string[]>}
+ */
+export function measureUntested(snapshot, history, index, prereg) {
+  const files = snapshot.files ?? [];
+  if (files.length === 0) return { value: null, reason: "no source files at this commit" };
+
+  const tests = snapshot.tests ?? [];
+  // Not an empty list: with no tests in the tree, "every module is untested"
+  // is arithmetically true and completely uninformative, and it would draw a
+  // cliff on the day the first test landed rather than on the day coverage
+  // actually changed.
+  if (tests.length === 0) return { value: null, reason: "no tests at this commit" };
+
+  // The same absence one level up: with no pack able to read a reference,
+  // every module would be reported untested on the strength of nothing having
+  // been read. The reason names the packs, so the reader can tell "no test
+  // names these" from "nothing opened these".
+  const speakers = packsWith(prereg, "mentions").filter((p) => typeof p.pack.keysFor === "function");
+  if (speakers.length === 0) {
+    return {
+      value: null,
+      reason: reasonFor(prereg, (p) =>
+        typeof p.pack.mentions === "function" && typeof p.pack.keysFor === "function"
+          ? null
+          : "no rule for how a test names a module in this language",
+      ),
+    };
+  }
+
+  const requireDir = prereg.UNTESTED_REQUIRE_DIR_SEGMENT !== false;
+  const mentioned = mentionsOf(tests, speakers, requireDir);
+  const speaks = new Set(speakers.map((p) => p.name));
+
+  const named = new Set();
+  const readable = [];
+  for (const f of files) {
+    // Each file is asked of the ONE pack that owns its extension: a module's
+    // keys are its own language's, and a file no pack can read is not a
+    // module no test names — it is a file nothing opened. It contributes no
+    // line in either direction.
+    const owner = packFor(f.path, prereg);
+    if (!owner || !speaks.has(owner.name)) continue;
+    readable.push({ f, owner });
+    const keys = owner.pack.keysFor(f.path);
+    // `requireDir` off is the bare-basename rule `UNTESTED_REQUIRE_DIR_SEGMENT`
+    // restores, and the pack's mention set then holds bare names. Every key a
+    // module answers to ends in that same basename, so the fallback is read
+    // off the keys rather than re-derived here — one definition of what a
+    // module is called, and it is the language's.
+    const hit = requireDir
+      ? keys.some((k) => mentioned.has(k))
+      : keys.some((k) => mentioned.has(k.slice(k.lastIndexOf("/") + 1)));
+    if (hit) named.add(f.path);
+  }
+
+  // Every source file belonged to a pack that cannot read a mention. The list
+  // would be empty, and an empty list here reads as "every module is named by
+  // a test" — the opposite of what happened.
+  if (readable.length === 0) {
+    return {
+      value: null,
+      reason: reasonFor(prereg, (p) =>
+        speaks.has(p.name) ? null : "no rule for how a test names a module in this language",
+      ),
+    };
+  }
+
+  // A pack with a mention rule and no import rule contributes no edge, so its
+  // modules are read on mentions alone — the definition this row had before
+  // reach existed, and never a guess in the other direction.
+  const reached = reachOf(readable, tests, prereg, requireDir);
+  const out = [];
+  const unnamed = [];
+  for (const { f } of readable) {
+    if (named.has(f.path)) continue;
+    if (reached.has(f.path)) unnamed.push(f.path);
+    else out.push(f.path);
+  }
+  out.sort();
+  unnamed.sort();
+  return { value: out, unnamed };
+}