@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/test/test-pinned.ts

@@ -1,18 +1,25 @@
 import { existsSync } from 'node:fs'
-import { readFile, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import { base_tree, type BaseTree } from '#scripts/git/base-tree'
+import { readFile } from 'node:fs/promises'
 import { change_base } from '#scripts/git/change-base'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { git_spawn } from '#scripts/git/git-spawn'
+import { review_code_tree } from '#scripts/review/review-code-tree'
+import { test_pinned_cache, type LoadedCache, type Reached } from './test-pinned-cache'
+import { test_pinned_cache_logic, type Known, type Recheck } from './test-pinned-cache-logic'
+import { test_pinned_emit } from './test-pinned-emit'
+import { test_pinned_functions } from './test-pinned-functions'
+import type { PinnedOrigin } from './test-pinned-ledger'
 import {
 	test_pinned_logic,
 	type Hunk,
+	type HunkOutcome,
 	type PinnedReport,
-	type UnpinnedHunk,
 } from './test-pinned-logic'
+import { test_pinned_probe, type CheckOptions, type Probe } from './test-pinned-probe'
+import { test_pinned_reach, type Reach } from './test-pinned-reach'
+import type { Staged } from './test-pinned-stage'
 import { test_red } from './test-red'
-import type { RedVerdict } from './test-red-logic'
+import type { RedProbe } from './test-red-logic'
 
 // `josh test:pinned` (joshuafolkken/kit#4516) — put each changed hunk of a non-test code file back to
 // the merge-base's lines, one at a time, run that file's related tests, and list the hunks no test went
@@ -22,12 +29,48 @@ import type { RedVerdict } from './test-red-logic'
 // The changed files are copied in from the working tree first, so what is reverted is the change as it
 // stands, committed or not, and each hunk's file is restored before the next one runs.
 
-const TREE_PREFIX = 'josh-test-pinned-'
 const HEAD = 'HEAD'
 
+interface StubRead {
+	hunks: ReadonlyArray<Hunk>
+	unparsed: ReadonlyArray<string>
+}
+
+// `rewired` counts the changed hunks left out as a rewire (`test-pinned-rewire.ts`).
+interface ProbeRead extends StubRead {
+	rewired: number
+}
+
+interface RunOptions {
+	max_hunks: number
+	is_cached_only: boolean
+	is_first_unpinned?: boolean
+	rewired?: number
+	origin?: PinnedOrigin | undefined
+}
+
+// One run's probing: the checked hunks, what the cache knows of each, and the cache they are written to.
+interface ProbeRun {
+	hunks: ReadonlyArray<Hunk>
+	known: ReadonlyArray<Known>
+	cache: LoadedCache
+	keys: ReadonlyArray<string>
+	options: RunOptions
+}
+
+// Each hunk's verdict, and how many of the fresh probes ran in stages.
+interface Verdicts {
+	verdicts: Array<RedProbe | undefined>
+	staged: Staged
+}
+
+const NO_OUTCOME: HunkOutcome = { unpinned: [], stopped: [] }
+const NO_REPORT = { ...NO_OUTCOME, unchecked: [], unparsed: [] } as const
+
 // `--diff-filter=M`: an added file's one hunk is the whole file, and reverting it is a missing module
-// every importer fails on, which says nothing about the tests. The prefixes are pinned: a user's
-// `diff.mnemonicPrefix` writes `+++ w/<file>`, which would read as no hunk at all.
+// every importer fails on, which says nothing about the tests — its functions are probed instead
+// (`stub_hunks_of`). The prefixes are pinned: a user's `diff.mnemonicPrefix` writes `+++ w/<file>`,
+// which would read as no hunk at all.
 async function read_hunks(base: string, files: ReadonlyArray<string>): Promise<Array<Hunk>> {
 	if (files.length === 0) return []
 	const diff_args = ['diff', '-U0', '--no-color', '--no-ext-diff', '--diff-filter=M']
@@ -38,63 +81,231 @@ async function read_hunks(base: string, files: ReadonlyArray<string>): Promise<A
 	)
 }
 
-// The verdict with this one hunk reverted. The file is put back before the next hunk runs, or that
-// hunk's tests would also see this revert.
-async function verdict_of(tree: BaseTree, hunk: Hunk): Promise<RedVerdict> {
-	const target = path.join(tree.tree, hunk.file)
-	const content = await readFile(target, 'utf8')
+// The key of each hunk, read off the working file its lines sit in now.
+async function keys_of(hunks: ReadonlyArray<Hunk>): Promise<Array<string>> {
+	const contents = await Promise.all(hunks.map(async (hunk) => await readFile(hunk.file, 'utf8')))
+
+	return test_pinned_cache_logic.distinct(
+		hunks.map((hunk, index) => test_pinned_cache_logic.hunk_key(hunk, contents[index] ?? '')),
+	)
+}
+
+// The verdict the cache already holds; one left to recheck holds none yet.
+function held_of(known: Known): RedProbe | undefined {
+	return test_pinned_cache_logic.is_recheck(known) ? undefined : known
+}
+
+function recheck_of(known: Known): Recheck | undefined {
+	return test_pinned_cache_logic.is_recheck(known) ? known : undefined
+}
+
+// The hunks no held verdict covers, each with its recheck where the cache named one.
+function probes_of(hunks: ReadonlyArray<Hunk>, known: ReadonlyArray<Known>): Array<Probe> {
+	return hunks
+		.map((hunk, index) => ({ hunk, index, recheck: recheck_of(known[index]) }))
+		.filter((probe) => held_of(known[probe.index]) === undefined)
+}
+
+// The probes in the order they run: the fewest tests reached first (`test_pinned_logic.by_reach`),
+// each file's count read once and carried on its probes, which a wide one runs in stages by
+// (`test-pinned-stage.ts`); a file with no graph to read counts as 0.
+async function by_reach(probes: ReadonlyArray<Probe>, reach: Reach): Promise<Array<Probe>> {
+	const files = test_pinned_cache_logic.distinct(probes.map((probe) => probe.hunk.file))
+	const related = await Promise.all(files.map(async (file) => await reach.related(file)))
+	const counts = new Map(files.map((file, index) => [file, related[index]?.length ?? 0]))
+	const counted = probes.map((probe) => ({ ...probe, reach: counts.get(probe.hunk.file) }))
+
+	return test_pinned_logic.by_reach(counted, counts)
+}
 
-	await writeFile(target, test_pinned_logic.revert(content, hunk))
+function reached_of(verdicts: ReadonlyArray<RedProbe | undefined>): Array<Reached> {
+	return verdicts.flatMap((verdict, index) => (verdict === undefined ? [] : [[index, verdict]]))
+}
 
-	try {
-		return await test_red.verdict_in(tree, ['related', hunk.file, '--run'])
-	} finally {
-		await writeFile(target, content)
+// The fresh run's options: the hunks the cache held, then the run's own.
+function check_options(held: number, options: RunOptions): CheckOptions {
+	return {
+		held,
+		rewired: options.rewired ?? 0,
+		is_first_unpinned: options.is_first_unpinned === true,
+		origin: options.origin,
 	}
 }
 
-// One hunk at a time: two reverts in flight would share the tree, and each run is already a whole vitest.
-// Green and no-test both leave a hunk unpinned: either way nothing went red when it was reverted.
-async function unpinned_in(
-	tree: BaseTree,
+// Each hunk's verdict: the cached one where it still holds, else a fresh run's, in the hunks' order.
+// The held ones are written first and each fresh one as it is reached (`test_pinned_cache.writer`).
+// Under `is_first_unpinned` a hunk the run stopped before keeps no verdict.
+async function verdicts_on(paths: ReadonlyArray<string>, probing: ProbeRun): Promise<Verdicts> {
+	const verdicts = probing.known.map((entry) => held_of(entry))
+	const reached = reached_of(verdicts)
+	const probes = await by_reach(probes_of(probing.hunks, probing.known), probing.cache.reach)
+	const writer = test_pinned_cache.writer(probing.cache, probing.keys)
+	const options = check_options(reached.length, probing.options)
+
+	await writer.record(reached)
+	const checked = await test_pinned_probe.checked_on(
+		paths,
+		probes,
+		async (index, verdict) => {
+			verdicts[index] = verdict
+			await writer.record([[index, verdict]])
+		},
+		options,
+	)
+
+	return { verdicts, staged: checked.staged }
+}
+
+function outcome_of(
 	hunks: ReadonlyArray<Hunk>,
-): Promise<Array<UnpinnedHunk>> {
-	const unpinned: Array<UnpinnedHunk> = []
+	verdicts: ReadonlyArray<RedProbe | undefined>,
+): HunkOutcome {
+	const is_held = verdicts.every((verdict) => verdict !== undefined)
 
-	for (const hunk of hunks) {
-		// eslint-disable-next-line no-await-in-loop -- the hunks share one tree, so each revert waits for the last restore
-		const verdict = await verdict_of(tree, hunk)
-		if (verdict !== 'red') unpinned.push({ ...hunk, is_green: verdict === 'green' })
-	}
+	return { ...test_pinned_logic.outcome(hunks, verdicts), is_held }
+}
 
-	return unpinned
+// The hunks a run probed and stopped before (`is_first_unpinned`); none, no `cut` key.
+function cut_of(
+	hunks: ReadonlyArray<Hunk>,
+	verdicts: ReadonlyArray<RedProbe | undefined>,
+): Pick<HunkOutcome, 'cut'> {
+	const cut = hunks.filter((_hunk, index) => verdicts[index] === undefined)
+
+	return cut.length === 0 ? {} : { cut }
 }
 
-async function unpinned_on(
+// A fresh cached verdict is reused without a run (`test-pinned-cache.ts`); every hunk's verdict is
+// stored again, so a rerun on the same tree starts no vitest. `is_cached_only` runs no probe: only the
+// verdicts the cache holds are read, and nothing is written.
+async function outcome_on(
+	base: string,
 	paths: ReadonlyArray<string>,
 	hunks: ReadonlyArray<Hunk>,
-): Promise<Array<UnpinnedHunk>> {
-	if (hunks.length === 0) return []
+	options: RunOptions,
+): Promise<HunkOutcome> {
+	if (hunks.length === 0) return NO_OUTCOME
+	const cache = await test_pinned_cache.load(base, hunks)
+	const keys = await keys_of(hunks)
+	const known = await test_pinned_cache.known(
+		cache,
+		keys,
+		hunks.map((hunk) => hunk.file),
+	)
+
+	if (options.is_cached_only) {
+		return outcome_of(
+			hunks,
+			known.map((entry) => held_of(entry)),
+		)
+	}
+
+	const { verdicts, staged } = await verdicts_on(paths, { hunks, known, cache, keys, options })
+
+	return { ...outcome_of(hunks, verdicts), ...cut_of(hunks, verdicts), staged }
+}
+
+// A target the base's tree does not hold is added — committed on the branch or still untracked.
+async function added_scripts(base: string, targets: ReadonlyArray<string>): Promise<Array<string>> {
+	const held = new Set(await changed_paths.read_held_at(base, targets))
 
-	return await base_tree.with_tree(TREE_PREFIX, HEAD, async (tree) => {
-		await base_tree.copy_in(tree.tree, paths)
+	return targets.filter((file) => !held.has(file) && test_pinned_functions.is_script(file))
+}
+
+// Without `typescript` (an optional peer in a consumer) no function can be read, so every added file
+// is reported unchecked rather than passed as pinned.
+async function stub_hunks_of(added: ReadonlyArray<string>): Promise<StubRead> {
+	const api = review_code_tree.load_typescript(process.cwd())
+	if (api === undefined) return { hunks: [], unparsed: added }
+	const contents = await Promise.all(added.map(async (file) => await readFile(file, 'utf8')))
+	const hunks = added.flatMap((file, index) =>
+		test_pinned_functions.stub_hunks(api, file, contents[index] ?? ''),
+	)
+
+	return { hunks, unparsed: [] }
+}
+
+// A changed hunk whose revert emits the same JavaScript, or a rewire, is dropped before the cap
+// (`test-pinned-emit.ts`), so neither is `unchecked`; without `typescript` every hunk is kept, so the
+// run checks more rather than less.
+async function runtime_hunks(hunks: ReadonlyArray<Hunk>): Promise<ProbeRead> {
+	const api = review_code_tree.load_typescript(process.cwd())
+	if (api === undefined) return { hunks: [...hunks], unparsed: [], rewired: 0 }
+	const contents = await Promise.all(hunks.map(async (hunk) => await readFile(hunk.file, 'utf8')))
+
+	return { ...test_pinned_emit.probed_of(api, hunks, contents), unparsed: [] }
+}
+
+async function read_probes(base: string, targets: ReadonlyArray<string>): Promise<ProbeRead> {
+	const stubs = await stub_hunks_of(await added_scripts(base, targets))
+	const changed = await runtime_hunks(await read_hunks(base, targets))
+	const hunks = [...changed.hunks, ...stubs.hunks]
+
+	return { hunks, unparsed: stubs.unparsed, rewired: changed.rewired }
+}
+
+// The work tree's files that differ from `commit`, deleted ones dropped. Read since `HEAD` they are
+// what the worktree at `HEAD` needs copied in to hold the work tree — a conflicted merge's incoming
+// files included; read since the change base they are this branch's own change.
+async function existing_since(commit: string): Promise<Array<string>> {
+	const changed = await changed_paths.read_changed_since(commit)
+
+	return changed.filter((file) => existsSync(file))
+}
+
+async function report_on(
+	base: string,
+	options: RunOptions,
+	has_runner: boolean,
+): Promise<PinnedReport> {
+	const { max_hunks } = options
+	const paths = await existing_since(HEAD)
+	const changed = await existing_since(base)
+	const targets = await test_pinned_reach.probed_files(
+		changed.filter((file) => test_pinned_logic.is_target(file)),
+	)
+	const probes = await read_probes(base, targets)
+	const { checked, unchecked } = test_pinned_logic.split(probes.hunks, has_runner ? max_hunks : 0)
+	const outcome = await outcome_on(base, paths, checked, { ...options, rewired: probes.rewired })
+
+	return { ...outcome, unchecked, unparsed: probes.unparsed, max_hunks, has_runner }
+}
+
+async function report(options: RunOptions): Promise<PinnedReport> {
+	const base = await change_base.resolved_through_merge()
+	const has_runner = test_red.has_runner()
+	if (base === undefined) return { ...NO_REPORT, max_hunks: options.max_hunks, has_runner }
+
+	return await report_on(base, options, has_runner)
+}
+
+// No merge-base (not a repository, no default branch) checks nothing, as `josh test:red` does. The cap
+// is shared: changed hunks first, then the added files' functions. Without Vitest (a consumer that has
+// none) no probe runs, so every one is unchecked rather than unpinned. `is_first_unpinned` starts no
+// probe once one is unpinned (joshuafolkken/kit#5153): the hunks left are reported `cut`. `origin` is
+// what started the run, for its ledger row.
+async function run(
+	max_hunks: number,
+	is_first_unpinned = false,
+	origin?: PinnedOrigin,
+): Promise<PinnedReport> {
+	return await report({ max_hunks, is_cached_only: false, is_first_unpinned, origin })
+}
 
-		return await unpinned_in(tree, hunks)
-	})
+// The unpinned hunks the cache already answers for this tree, probing nothing (joshuafolkken/kit#4936):
+// what a check still running — or one stopped mid-way — has reached for the hunks that did not move.
+async function cached(max_hunks: number): Promise<PinnedReport> {
+	return await report({ max_hunks, is_cached_only: true })
 }
 
-// No merge-base (not a repository, no default branch) checks nothing, as `josh test:red` does.
-async function run(max_hunks: number): Promise<PinnedReport> {
-	const base = await change_base.resolved()
-	const changed = await changed_paths.read_changed_paths(false)
-	const paths = changed.filter((file) => existsSync(file))
-	const targets = paths.filter((file) => test_pinned_logic.is_target(file))
-	const hunks = base === undefined ? [] : await read_hunks(base, targets)
-	const { checked, unchecked } = test_pinned_logic.split(hunks, max_hunks)
+// The cached report when the cache holds every checked hunk's verdict for this tree, probing nothing
+// (joshuafolkken/kit#5078); `undefined` when a hunk moved or was never probed, so the caller probes.
+async function held_report(max_hunks: number): Promise<PinnedReport | undefined> {
+	const read = await cached(max_hunks)
 
-	return { unpinned: await unpinned_on(paths, checked), unchecked, max_hunks }
+	return read.is_held === true ? read : undefined
 }
 
-const test_pinned = { run }
+const test_pinned = { cached, held_report, run }
 
 export { test_pinned }

package/scripts/test/test-reach-cli.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env tsx
+import { existsSync, statSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { test_pinned_reach } from './test-pinned-reach'
+
+// `josh test:reach <file...>` — how many test files each file's imports reach, the count
+// `josh test:related` sizes its core claim by, one `<count> <file>` line per file
+// (joshuafolkken/kit#5238): an overrun filing or a baseline measures it without a hand-written probe.
+
+const ARGV_OFFSET = 2
+const FAILURE_EXIT_CODE = 1
+const USAGE = 'Usage: josh test:reach <file...>'
+const NO_GRAPH =
+	'josh test:reach: no import graph can be built here (no typescript or tsconfig.json)'
+
+function is_file(path: string): boolean {
+	return existsSync(path) && statSync(path).isFile()
+}
+
+// A path no file answers — absent, or a directory — reaches no test, so its `0` would read as a
+// measured count: `pnpm josh` runs from the repository root, where a path typed relative to a
+// subdirectory names nothing.
+function refusal(argv: ReadonlyArray<string>): string | undefined {
+	if (argv.length === 0) return USAGE
+	const missing = argv.filter((file) => !is_file(file))
+	if (missing.length === 0) return undefined
+
+	return `josh test:reach: no such file from the repository root: ${missing.join(', ')}`
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const refused = refusal(argv)
+
+	if (refused !== undefined) {
+		console.error(refused)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	const counts = await test_pinned_reach.reached_test_counts(argv)
+
+	if (counts === undefined) {
+		console.error(NO_GRAPH)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	console.info(counts.map(({ file, count }) => `${String(count)} ${file}`).join('\n'))
+
+	return 0
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const test_reach_cli = { USAGE, run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { test_reach_cli }

package/scripts/test/test-read-map.ts

@@ -1,6 +1,7 @@
 import { readdirSync, readFileSync, rmSync, statSync } from 'node:fs'
 import path from 'node:path'
 import { git_common_directory } from '#scripts/git/git-common-directory'
+import { run_record_path } from '#scripts/josh/run-record-path'
 import { atomic_write } from '#scripts/lib/atomic-write'
 import { json_value } from '#scripts/lib/json-value'
 import { test_read_trace, type ReadRecords } from './test-read-trace'
@@ -24,6 +25,10 @@ interface ReadMap {
 	// content then (`input_fingerprint.of_files`), so one whose content has not moved since does not count as changed
 	// (joshuafolkken/kit#4425).
 	dirty: Record<string, string>
+	// The recording checkout's change as a test reads it through git — the branch diff from the change
+	// base plus the untracked files (`changed_paths.read_changed_paths`), committed or not
+	// (joshuafolkken/kit#4734).
+	change: Array<string>
 	// The directories `commit` holds, so a directory new since then is told apart from one no test
 	// read — the map's own keys cannot say which, since an unread directory has none.
 	directories: Array<string>
@@ -32,10 +37,11 @@ interface ReadMap {
 
 // Bumped whenever the shape, what a reader means or how `dirty` is digested changes, so a map an older
 // kit wrote reads as no map at all and the next full run writes it afresh. 6: `dirty` is
-// `input-fingerprint.ts`'s digest of every changed file (joshuafolkken/kit#4497).
-const MAP_VERSION = 6
+// `input-fingerprint.ts`'s digest of every changed file (joshuafolkken/kit#4497). 7: `change`
+// (joshuafolkken/kit#4734). 8: a module is a reader only of what its evaluation read
+// (joshuafolkken/kit#5033).
+const MAP_VERSION = 8
 
-const MAP_DIRECTORY = 'josh'
 const MAP_FILE_STEM = 'test-read-map'
 const RECORD_EXTENSION = '.json'
 
@@ -84,6 +90,7 @@ const FIELD_CHECKS: ReadonlyArray<[keyof ReadMap, (field: unknown) => boolean]>
 	['version', (field) => field === MAP_VERSION],
 	['commit', (field) => typeof field === 'string'],
 	['dirty', is_digest_record],
+	['change', is_string_array],
 	['directories', is_string_array],
 	['readers', is_read_records],
 ]
@@ -148,7 +155,13 @@ function created_directories(
 // it. A directory new since the recording is also a new entry in the listing above it and a probe of
 // it that now answers differently; a directory that already existed reads the same to both, whatever
 // changed deeper down.
+//
+// **A run record reaches only a test that read it by name** (joshuafolkken/kit#5001): a test listing or
+// walking the root or `.josh/` reads the checkout around it, not the observation or accepted metrics
+// a lane writes after its checks went green, so those keys would run every such test for bookkeeping.
 function lookup_keys(relative: string, recorded: ReadonlySet<string>): Array<string> {
+	if (run_record_path.is_run_record(relative)) return [relative]
+
 	const directories = directories_above(relative)
 	const created = created_directories(directories, recorded)
 	const listed = [
@@ -170,23 +183,34 @@ function readers_of(map: ReadMap, relative: string): Array<string> {
 	return [...new Set(keys.flatMap((key) => map.readers[key] ?? []))]
 }
 
-// **A directory the recorded tree held, inside which no recorded test listed, walked or read any
-// entry** (joshuafolkken/kit#4303). A file added to it since is one no test reads, as surely as one
-// the tree already held there: a test that builds a path into it reads some file there, and one that
-// enumerates it lists it, both of which leave a key whose directory is this one.
+// **A directory inside which no recorded test listed, walked or read any entry** (joshuafolkken/kit#4303).
+// A file added to it since is one no test reads, as surely as one the tree already held there: a test
+// that builds a path into it reads some file there, and one that enumerates it lists it, both of which
+// leave a key whose directory is this one — a read is recorded before it runs, so a path absent then
+// still leaves its key. **A directory new since the recording counts too** (joshuafolkken/kit#4597):
+// a probe of it or a listing of its parent is one of `readers_of`'s keys, which the caller asks first.
+// **A read of the recording tree's own change does not count** (joshuafolkken/kit#4734): a test that
+// reads this checkout's change through git reads whatever file the recording lane held, so its own
+// `.josh/metrics-accepted/<N>.json` marked that directory read and sent the next lane's to the whole
+// suite. A listing or a walk of the directory, or a read of any other file there, still counts — except
+// for a run record, which only a read of itself reaches (`lookup_keys`).
 function in_unread_directory(map: ReadMap, relative: string): boolean {
-	const directory = path.dirname(relative)
+	if (run_record_path.is_run_record(relative)) return true
 
-	if (!map.directories.includes(directory)) return false
+	const directory = path.dirname(relative)
+	const change = new Set(map.change)
+	const keys = Object.keys(map.readers).filter((key) => !change.has(key))
 
-	return Object.keys(map.readers).every((key) => path.dirname(key) !== directory)
+	return keys.every((key) => path.dirname(key) !== directory)
 }
 
 function map_path(root: string, version: number = MAP_VERSION): string | undefined {
 	const common = git_common_directory.repository(root)
 	const name = `${MAP_FILE_STEM}.v${String(version)}${RECORD_EXTENSION}`
 
-	return common === undefined ? undefined : path.join(common, MAP_DIRECTORY, name)
+	return common === undefined
+		? undefined
+		: path.join(common, git_common_directory.STATE_DIRECTORY, name)
 }
 
 // Every version's map, the unversioned one kits before joshuafolkken/kit#4423 wrote included; a

package/scripts/test/test-read-recording.ts

@@ -36,16 +36,28 @@ async function commit_directories(commit: string): Promise<Array<string>> {
 	return output.split('\0').filter((listed) => listed.length > 0)
 }
 
-type TreeSnapshot = Pick<ReadMap, 'commit' | 'dirty' | 'directories'>
+type TreeSnapshot = Pick<ReadMap, 'commit' | 'dirty' | 'change' | 'directories'>
 
-// The tree the run read: the commit, every file that differed from it with its content's digest, and
-// the directories it holds. **Read before the run starts**: a digest taken after it would vouch for
-// an edit made while the tests ran as content they read.
+// A checkout with no change base (no default-branch ref) still records its map, with no change to
+// discount: every read then counts, which narrows less, never wrongly.
+async function own_change(): Promise<Array<string>> {
+	try {
+		return await changed_paths.read_changed_paths(false)
+	} catch {
+		return []
+	}
+}
+
+// The tree the run read: the commit, every file that differed from it with its content's digest, the
+// checkout's change from its change base, and the directories it holds. **Read before the run
+// starts**: a digest taken after it would vouch for an edit made while the tests ran as content they
+// read.
 async function tree_snapshot(root: string): Promise<TreeSnapshot> {
 	const commit = await git_command.head_commit()
 	const dirty = input_fingerprint.of_files(root, await changed_paths.read_changed_since(commit))
+	const change = await own_change()
 
-	return { commit, dirty, directories: await commit_directories(commit) }
+	return { commit, dirty, change, directories: await commit_directories(commit) }
 }
 
 // A map that cannot be written — no git, a read-only common directory — leaves the previous map in

package/scripts/test/test-read-trace.ts

@@ -12,6 +12,15 @@ import { fileURLToPath } from 'node:url'
 // makes has the test outermost, so a shared helper it reads through — every test importing it — is
 // never the reader (joshuafolkken/kit#4417). The test file is recorded beside it, because an async
 // callback (a directory walk inside a dependency) leaves no repository frame at all.
+//
+// **Only a module's evaluation makes a module the reader** (joshuafolkken/kit#5033). A read a named
+// function makes after an `await` has that function outermost, since the continuation drops the test
+// that called it: `import-graph.ts` read some 3,700 paths that way, and `vitest related` widened each
+// to every test importing it. Such a read belongs to the test running it, recorded beside, so an
+// outermost frame with a function name records no module. A module's top-level code runs with no
+// function name; so does an anonymous callback, which keeps the widening — the safe side. A top-level
+// `await` of a named function that reads after an `await` of its own narrows to the first importing
+// test; no module does that today, and CI's whole suite would catch the miss.
 
 type ReadRecords = Record<string, Array<string>>
 
@@ -95,16 +104,23 @@ function read_target(argument: unknown, cwd: string): string | undefined {
 	return undefined
 }
 
+// One call site: its script name, and the name of the function running there — empty for a module's
+// top-level code or an anonymous callback.
+interface CallFrame {
+	script_name: string
+	function_name: string
+}
+
 interface ReaderQuery {
 	root: string
-	// The script name of every call site, innermost first.
-	scripts: ReadonlyArray<string>
+	// Every call site, innermost first.
+	frames: ReadonlyArray<CallFrame>
 	// The recorder's own file, which is always the top frame and never the reader.
 	recorder: string
 }
 
-function frame_reader(query: ReaderQuery, script_name: string): string | undefined {
-	const file_path = script_path(script_name)
+function frame_reader(query: ReaderQuery, frame: CallFrame): string | undefined {
+	const file_path = script_path(frame.script_name)
 
 	if (file_path === undefined || file_path === query.recorder) return undefined
 
@@ -114,9 +130,11 @@ function frame_reader(query: ReaderQuery, script_name: string): string | undefin
 }
 
 function stack_reader(query: ReaderQuery): string | undefined {
-	return query.scripts
-		.map((script_name) => frame_reader(query, script_name))
-		.findLast((reader) => reader !== undefined)
+	const outermost = query.frames.findLast((frame) => frame_reader(query, frame) !== undefined)
+
+	if (outermost?.function_name !== '') return undefined
+
+	return frame_reader(query, outermost)
 }
 
 function add_reader(records: Map<string, Set<string>>, read_path: string, reader: string): void {
@@ -144,5 +162,5 @@ const test_read_trace = {
 	to_records,
 }
 
-export type { ReadKind, ReaderQuery, ReadRecords }
+export type { CallFrame, ReadKind, ReaderQuery, ReadRecords }
 export { test_read_trace }