@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/test/test-pinned-main.ts

@@ -1,29 +1,49 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'node:util'
+import { review_tree } from '#scripts/review/review-tree'
 import { test_pinned } from './test-pinned'
+import { test_pinned_ledger, type PinnedOrigin } from './test-pinned-ledger'
 import { test_pinned_logic, type PinnedReport } from './test-pinned-logic'
+import { test_pinned_record, type PinnedSummary } from './test-pinned-record'
 
-// The `josh test:pinned` entry: read `--max`, run, print one line per unpinned or unchecked hunk, and
-// exit non-zero when any checked hunk is unpinned. An unchecked hunk alone does not fail the run — it
+// The `josh test:pinned` entry: read `--max`, run, print one line per unpinned hunk and per unchecked
+// reason (each unchecked place in the `full output:` log), and exit non-zero when any checked hunk is unpinned. An unchecked hunk alone does not fail the run — it
 // was not asked about.
 
 const CLEAN_EXIT = 0
 const FAILED_EXIT = 1
 const ARGV_OFFSET = 2
 const USAGE = [
-	'Usage: josh test:pinned [--max <n>] [--help]',
-	'  revert each changed hunk of a non-test code file and run its related tests;',
+	'Usage: josh test:pinned [--max <n>] [--record <token>] [--origin <run-review|pre-detach|manual>] [--first-unpinned] [--help]',
+	'  revert each changed code hunk outside tests and fixtures only they reach, and run its related tests;',
 	'  prints `unpinned <file>:<line>` for a hunk no test went red on, and',
-	`  \`unchecked <file>:<line>\` past the --max cap (default ${String(test_pinned_logic.DEFAULT_MAX_HUNKS)})`,
+	`  \`unchecked <n> — <reason>\` for the hunks past the --max cap (default ${String(test_pinned_logic.DEFAULT_MAX_HUNKS)})`,
+	'  or whose revert stopped vitest before any test ran, each place listed in the `full output:` log;',
+	'  --record also leaves the answer, under <token>, for `josh run:review --join`;',
+	'  --origin names what started the run on its lane ledger row (default manual);',
+	'  hunks run fewest reached tests first, and --first-unpinned starts no probe once one is unpinned',
 ].join('\n')
 
 const PARSE_ARGS_OPTIONS = {
 	help: { type: 'boolean', short: 'h', default: false },
+	'first-unpinned': { type: 'boolean', default: false },
 	max: { type: 'string' },
+	origin: { type: 'string' },
+	record: { type: 'string' },
 } as const
 
 const HELP_FLAGS: ReadonlySet<string> = new Set(['--help', '-h'])
+// A tree still moving after this many checks is answered as not checked rather than waited on.
+const MAX_CHECKS = 3
+const MOVING_NOTE = `the tree kept moving across ${String(MAX_CHECKS)} checks`
+
+interface PinnedOptions {
+	max_hunks: number
+	record_token: string | undefined
+	is_first_unpinned: boolean
+	origin: PinnedOrigin
+}
 
 // A `--max` that is not a whole number above zero is a refusal, not the default.
 function valid_max(raw: string | undefined): number | undefined {
@@ -32,12 +52,22 @@ function valid_max(raw: string | undefined): number | undefined {
 	return Number.isSafeInteger(max) && max > 0 ? max : undefined
 }
 
-// `undefined` prints the usage: a help request, an unknown flag, or a missing or invalid `--max`.
-function max_hunks_of(argv: ReadonlyArray<string>): number | undefined {
+// `undefined` prints the usage: a help request, an unknown flag, a missing or invalid `--max`, or an
+// `--origin` not among the three.
+function options_of(argv: ReadonlyArray<string>): PinnedOptions | undefined {
 	try {
 		const { values } = parseArgs({ args: [...argv], options: PARSE_ARGS_OPTIONS, strict: true })
+		const max_hunks = valid_max(values.max)
+		const origin = test_pinned_ledger.origin_of(values.origin)
+
+		if (max_hunks === undefined || origin === undefined || values.help) return undefined
 
-		return values.help ? undefined : valid_max(values.max)
+		return {
+			max_hunks,
+			record_token: values.record,
+			is_first_unpinned: values['first-unpinned'],
+			origin,
+		}
 	} catch {
 		return undefined
 	}
@@ -50,23 +80,59 @@ function print_usage(argv: ReadonlyArray<string>): number {
 	return argv.some((argument) => HELP_FLAGS.has(argument)) ? CLEAN_EXIT : FAILED_EXIT
 }
 
-function output(report: PinnedReport): string {
-	const unpinned = String(report.unpinned.length)
-	const unchecked = String(report.unchecked.length)
-	const lines = [`unpinned ${unpinned} · unchecked ${unchecked}`, test_pinned_logic.format(report)]
+async function tree_digest(): Promise<string> {
+	return JSON.stringify(await review_tree.read_changed_tree())
+}
+
+// The recorded check runs beside a review that may fix in place, and it reads the tree at more than
+// one moment; a check the tree moved under is run again, so its answer is about one tree.
+async function settled_run(options: PinnedOptions): Promise<PinnedReport> {
+	for (let attempt = 0; attempt < MAX_CHECKS; attempt += 1) {
+		// eslint-disable-next-line no-await-in-loop -- each check runs only once the last one saw the tree move
+		const before = await tree_digest()
+		// eslint-disable-next-line no-await-in-loop -- as above
+		const report = await test_pinned.run(
+			options.max_hunks,
+			options.is_first_unpinned,
+			options.origin,
+		)
+		// eslint-disable-next-line no-await-in-loop -- as above
+		if ((await tree_digest()) === before) return report
+	}
+
+	throw new Error(MOVING_NOTE)
+}
+
+// `--record` leaves an answer however the run ends — a check that could not run included — so the
+// join waiting on it never waits on a check that died.
+async function recorded_run(options: PinnedOptions, token: string): Promise<PinnedSummary> {
+	try {
+		const summary = test_pinned_record.summary_of(await settled_run(options))
+
+		test_pinned_record.write(token, summary)
+
+		return summary
+	} catch (error: unknown) {
+		test_pinned_record.write(token, test_pinned_record.not_run_summary(error))
 
-	return `${lines.filter((line) => line !== '').join('\n')}\n`
+		throw error
+	}
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<number> {
-	const max_hunks = max_hunks_of(argv)
-	if (max_hunks === undefined) return print_usage(argv)
+	const options = options_of(argv)
+	if (options === undefined) return print_usage(argv)
 
-	const report = await test_pinned.run(max_hunks)
+	const summary =
+		options.record_token === undefined
+			? test_pinned_record.summary_of(
+					await test_pinned.run(options.max_hunks, options.is_first_unpinned, options.origin),
+				)
+			: await recorded_run(options, options.record_token)
 
-	process.stdout.write(output(report))
+	process.stdout.write(test_pinned_logic.report_text(summary))
 
-	return report.unpinned.length === 0 ? CLEAN_EXIT : FAILED_EXIT
+	return summary.unpinned.length === 0 ? CLEAN_EXIT : FAILED_EXIT
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {

package/scripts/test/test-pinned-pool.ts

@@ -0,0 +1,73 @@
+// How `josh test:pinned` spreads its hunk checks over detached worktrees (joshuafolkken/kit#4706).
+//
+// **Two reverts in flight never share a tree**: each lane holds a tree of its own and checks its hunks
+// one at a time, so a hunk's run sees only its own revert, as the serial run did. **The lanes fit the
+// worker budget the run was admitted on** — at most one lane per worker, each vitest capped to its
+// part of the budget — and never more than `MAX_TREES`, since each lane checks out a whole worktree.
+
+const MAX_TREES = 4
+const UNREAD_BUDGET = 1
+
+interface LanePlan {
+	lanes: number
+	workers: number
+}
+
+// `budget` is the vitest workers the run may use; an unread one runs a single lane.
+function lane_plan(count: number, budget: number = UNREAD_BUDGET): LanePlan {
+	const lanes = Math.max(1, Math.min(count, budget, MAX_TREES))
+
+	return { lanes, workers: Math.max(1, Math.floor(budget / lanes)) }
+}
+
+// The items each lane takes, dealt round-robin so the lanes stay within one item of each other.
+function deal<T>(items: ReadonlyArray<T>, lanes: number): Array<Array<T>> {
+	const groups: Array<Array<T>> = Array.from({ length: lanes }, () => [])
+
+	for (const [index, item] of items.entries()) groups[index % lanes]?.push(item)
+
+	return groups.filter((group) => group.length > 0)
+}
+
+// The lanes' answers, or the first lane's failure once every lane has ended — a failed lane never
+// returns while the others still run their trees beside whatever the caller does next.
+function settled<R>(outcomes: ReadonlyArray<PromiseSettledResult<R>>): Array<R> {
+	const failed = outcomes.find((outcome) => outcome.status === 'rejected')
+	if (failed !== undefined) throw failed.reason
+
+	return outcomes.flatMap((outcome) => (outcome.status === 'fulfilled' ? [outcome.value] : []))
+}
+
+// Runs every lane at once; a lane answers its own items in the order it was dealt them.
+async function run_lanes<T, R>(
+	items: ReadonlyArray<T>,
+	lanes: number,
+	run_lane: (group: ReadonlyArray<T>) => Promise<ReadonlyArray<R>>,
+): Promise<Array<ReadonlyArray<R>>> {
+	return settled(
+		await Promise.allSettled(deal(items, lanes).map(async (group) => await run_lane(group))),
+	)
+}
+
+// The one-item slice of lane `index % lanes` that holds item `index`.
+function at(index: number, lanes: number): [number, number] {
+	const position = Math.floor(index / lanes)
+
+	return [position, position + 1]
+}
+
+// The lanes' results put back in the items' own order, whatever order the lanes finished in: item
+// `index` sat at `floor(index / lanes)` in lane `index % lanes`.
+async function run_pool<T, R>(
+	items: ReadonlyArray<T>,
+	lanes: number,
+	run_lane: (group: ReadonlyArray<T>) => Promise<ReadonlyArray<R>>,
+): Promise<Array<R>> {
+	const results = await run_lanes(items, lanes, run_lane)
+
+	return items.flatMap((_item, index) => results[index % lanes]?.slice(...at(index, lanes)) ?? [])
+}
+
+const test_pinned_pool = { MAX_TREES, deal, lane_plan, run_pool }
+
+export { test_pinned_pool }

package/scripts/test/test-pinned-probe.ts

@@ -0,0 +1,254 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { base_tree, type BaseTree } from '#scripts/git/base-tree'
+import { direct_importers } from './direct-importers'
+import { related_heavy_tests } from './related-heavy-tests'
+import { test_pinned_cache_logic, type Recheck } from './test-pinned-cache-logic'
+import { test_pinned_ledger, type PinnedOrigin, type ProbeTime } from './test-pinned-ledger'
+import { test_pinned_logic, type Hunk } from './test-pinned-logic'
+import { test_pinned_pool } from './test-pinned-pool'
+import { test_pinned_stage, type Staged, type StagePlan } from './test-pinned-stage'
+import { test_red } from './test-red'
+import type { RedProbe } from './test-red-logic'
+import { related_scope, type RelatedScope } from './test-related-scope'
+import { test_unit_guard } from './test-unit-guard'
+import { unit_worker_share } from './unit-worker-share'
+
+// The probes of `josh test:pinned` (joshuafolkken/kit#4516): each hunk reverted alone in a detached
+// worktree at HEAD (`base-tree.ts`), and its related tests run. **Each verdict is handed on as soon as
+// it is reached** (joshuafolkken/kit#4936), so the caller stores it before the next hunk runs.
+//
+// A hunk with a `recheck` runs only those tests — the ones added or edited since its stored `green` or
+// `no-test` verdict, or the ones its stored `red` failed in (`test-pinned-cache-logic.ts`); a `red`
+// recheck they no longer fail falls back to a fresh probe, which runs in stages where the file's reach
+// is wide (`test-pinned-stage.ts`).
+
+const TREE_PREFIX = 'josh-test-pinned-'
+const HEAD = 'HEAD'
+const NO_TEST: RedProbe = { verdict: 'no-test', failed: [], ran: 0 }
+
+// One hunk to probe, with the index of its verdict among the caller's hunks and how many test files
+// its file reaches, where a graph counted them.
+interface Probe {
+	hunk: Hunk
+	index: number
+	recheck?: Recheck | undefined
+	reach?: number | undefined
+}
+
+type OnVerdict = (index: number, verdict: RedProbe) => Promise<void>
+
+async function direct_of(root: string, file: string): Promise<Array<string>> {
+	const importers = await direct_importers.importers_of(root, [file])
+
+	return importers.get(file) ?? []
+}
+
+// What a fresh probe of the hunk runs in the tree at `root` (`test-pinned-stage.ts`). A file every
+// test imports stays the special case of joshuafolkken/kit#5122: its direct importers alone, never
+// escalated, since its reach is the whole suite — and `vitest related` handed it runs the whole suite.
+async function plan_of(root: string, probe: Probe): Promise<StagePlan> {
+	const { file } = probe.hunk
+
+	if (direct_importers.every_test_imports_of([file]).length > 0) {
+		return { reach: await direct_of(root, file) }
+	}
+
+	if (probe.reach === undefined) return { reach: [file] }
+
+	return test_pinned_stage.plan_over(file, await direct_of(root, file), probe.reach)
+}
+
+// The tests `files` reach in the tree at `root`, the heavy files reached only indirectly left out
+// (`josh test:related`'s rule). `undefined` when there are none.
+function selection_over(
+	root: string,
+	files: ReadonlyArray<string>,
+	workers: number,
+): Array<string> | undefined {
+	if (files.length === 0) return undefined
+
+	// vitest is handed the paths relative to the tree it runs in, as the exclusion reads them.
+	const scope: RelatedScope = { mode: 'related', files, reason: '' }
+	const placed: RelatedScope = { ...scope, files: files.map((test) => path.join(root, test)) }
+	const flags = related_heavy_tests.exclude_flags(placed, root)
+
+	return [
+		...related_scope.vitest_arguments(scope, flags),
+		...unit_worker_share.worker_arguments([], workers),
+	]
+}
+
+function recheck_selection(recheck: Recheck, workers: number): Array<string> {
+	return ['run', ...recheck.recheck, ...unit_worker_share.worker_arguments([], workers)]
+}
+
+// The probe's first run: its recheck, or the first stage of its plan.
+async function selection_of(
+	root: string,
+	probe: Probe,
+	workers: number,
+): Promise<Array<string> | undefined> {
+	if (probe.recheck !== undefined) return recheck_selection(probe.recheck, workers)
+	const plan = await plan_of(root, probe)
+
+	return selection_over(root, plan.direct ?? plan.reach, workers)
+}
+
+// The run 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 reverted_run(
+	tree: BaseTree,
+	hunk: Hunk,
+	selection: ReadonlyArray<string> | undefined,
+): Promise<RedProbe> {
+	if (selection === undefined) return NO_TEST
+
+	const target = path.join(tree.tree, hunk.file)
+	const content = await readFile(target, 'utf8')
+
+	await writeFile(target, test_pinned_logic.revert(content, hunk))
+
+	try {
+		return await test_red.probe_in(tree, selection)
+	} finally {
+		await writeFile(target, content)
+	}
+}
+
+// Set once a probe is unpinned in a `--first-unpinned` run (joshuafolkken/kit#5153): no lane starts
+// another probe, and the ones already running finish and hand their verdicts on.
+interface Halt {
+	is_set: boolean
+}
+
+// What every lane of one run shares: its workers per tree, the caller's hand-off, the probes' times,
+// how many probes ran in stages, and the halt a `--first-unpinned` run carries.
+interface Lane {
+	workers: number
+	on_verdict: OnVerdict
+	times: Array<ProbeTime>
+	staged: Staged
+	halt?: Halt | undefined
+}
+
+// The hunk's verdict over every stage of its plan.
+async function fresh_verdict(tree: BaseTree, probe: Probe, lane: Lane): Promise<RedProbe> {
+	const plan = await plan_of(tree.tree, probe)
+
+	async function run(files: ReadonlyArray<string>): Promise<RedProbe> {
+		return await reverted_run(tree, probe.hunk, selection_over(tree.tree, files, lane.workers))
+	}
+
+	return await test_pinned_stage.staged_verdict(plan, run, lane.staged)
+}
+
+// The hunk's verdict: its recheck's answer, or a fresh probe where it answers none.
+async function verdict_of(tree: BaseTree, probe: Probe, lane: Lane): Promise<RedProbe> {
+	if (probe.recheck === undefined) return await fresh_verdict(tree, probe, lane)
+	const selection = recheck_selection(probe.recheck, lane.workers)
+	const run = await reverted_run(tree, probe.hunk, selection)
+
+	return (
+		test_pinned_cache_logic.rechecked(probe.recheck, run) ??
+		(await fresh_verdict(tree, probe, lane))
+	)
+}
+
+function halt_on(lane: Lane, verdict: RedProbe): void {
+	if (lane.halt !== undefined && test_pinned_logic.is_unpinned(verdict)) lane.halt.is_set = true
+}
+
+async function timed_verdict(tree: BaseTree, probe: Probe, lane: Lane): Promise<RedProbe> {
+	const started = Date.now()
+	const verdict = await verdict_of(tree, probe, lane)
+
+	lane.times.push(test_pinned_ledger.time_of(probe.hunk, verdict, Date.now() - started))
+
+	return verdict
+}
+
+// One hunk at a time within a lane: its hunks share the lane's tree (`test-pinned-pool.ts`). A set
+// halt starts no further hunk, so the lane answers fewer than it was dealt.
+async function verdicts_in(
+	tree: BaseTree,
+	probes: ReadonlyArray<Probe>,
+	lane: Lane,
+): Promise<Array<RedProbe>> {
+	const verdicts: Array<RedProbe> = []
+
+	for (const probe of probes) {
+		if (lane.halt?.is_set === true) break
+		// eslint-disable-next-line no-await-in-loop -- the hunks share one tree, so each revert waits for the last restore
+		const verdict = await timed_verdict(tree, probe, lane)
+
+		halt_on(lane, verdict)
+		// eslint-disable-next-line no-await-in-loop -- stored before the next hunk runs, so a stopped run keeps it
+		await lane.on_verdict(probe.index, verdict)
+		verdicts.push(verdict)
+	}
+
+	return verdicts
+}
+
+async function pooled(
+	paths: ReadonlyArray<string>,
+	probes: ReadonlyArray<Probe>,
+	lane: Omit<Lane, 'workers'>,
+): Promise<Array<RedProbe>> {
+	if (probes.length === 0) return []
+	const plan = test_pinned_pool.lane_plan(probes.length, await test_unit_guard.vitest_share([]))
+
+	return await test_pinned_pool.run_pool(
+		probes,
+		plan.lanes,
+		async (group) =>
+			await base_tree.with_tree(TREE_PREFIX, HEAD, async (tree) => {
+				await base_tree.copy_in(tree.tree, paths)
+
+				return await verdicts_in(tree, group, { ...lane, workers: plan.workers })
+			}),
+	)
+}
+
+// `held` counts the hunks the cache answered, `rewired` the ones left out as a rewire
+// (`test-pinned-rewire.ts`); `is_first_unpinned` starts no probe once one is unpinned.
+interface CheckOptions {
+	held?: number
+	rewired?: number
+	is_first_unpinned?: boolean
+	origin?: PinnedOrigin | undefined
+}
+
+// The verdicts reached, in the probes' order, and how many of the probes ran in stages.
+interface Checked {
+	verdicts: Array<RedProbe>
+	staged: Staged
+}
+
+// The probes, checked over as many trees as the worker budget allows; `paths` are copied into each.
+// The run's ledger row counts the `held` hunks beside the probed ones' times. Under
+// `is_first_unpinned`, the verdicts are the ones started before the first unpinned verdict.
+async function checked_on(
+	paths: ReadonlyArray<string>,
+	probes: ReadonlyArray<Probe>,
+	on_verdict: OnVerdict,
+	options: CheckOptions = {},
+): Promise<Checked> {
+	const started = Date.now()
+	const times: Array<ProbeTime> = []
+	const staged = test_pinned_stage.none()
+	const halt = options.is_first_unpinned === true ? { is_set: false } : undefined
+	const verdicts = await pooled(paths, probes, { on_verdict, times, staged, halt })
+
+	const skipped = { held: options.held ?? 0, rewired: options.rewired ?? 0, origin: options.origin }
+
+	await test_pinned_ledger.record(skipped, times, Date.now() - started)
+
+	return { verdicts, staged }
+}
+
+const test_pinned_probe = { checked_on, selection_of }
+
+export type { CheckOptions, Checked, Probe }
+export { test_pinned_probe }

package/scripts/test/test-pinned-prune-logic.ts

@@ -0,0 +1,118 @@
+import { test_pinned_cache_logic, type GreenHunk } from './test-pinned-cache-logic'
+import { test_pinned_logic, type Hunk } from './test-pinned-logic'
+
+// What lets a `red` verdict outlive the removal of an unpinned line (joshuafolkken/kit#5004). Removing
+// the line a `green` probe named changes the code change and the failed test's import closure both, yet
+// that line could be reverted with every test green, so the other hunks' `red` verdicts still hold.
+//
+// **The cache records each `green` hunk and `pruned`: the code change with exactly those hunks
+// reverted.** A
+// later run reverts each of its own hunks that is only what is left of a recorded one — the same base
+// lines, its lines a subsequence of that one's — and a `pruned` that reads the same means the code
+// change since differs only by lines removed from `green` hunks. Any other edit reads differently. A
+// hunk that lost lines has a key of its own, so it is probed afresh. A matching hunk is not tied to its
+// recorded position, so a `green` line moved elsewhere in its file reads as one removed — a stretch the
+// diff's line numbers cannot settle, since every edit above a hunk shifts them.
+
+// The code change a `pruned` digest is read off: the base commit, each changed non-test path and its
+// content digest.
+interface CodeChange {
+	commit: string
+	code: ReadonlyArray<string>
+	digests: ReadonlyMap<string, string>
+}
+
+// A stub probe on an added file puts back a body it wrote, not the base's lines, so it records nothing.
+function is_line_hunk(hunk: Hunk): boolean {
+	return hunk.function_name === undefined
+}
+
+// The line hunks whose verdict is `green` — the ones the cache records, and the only ones its `pruned`
+// reverts: a hunk that only resembles one stays, so removing it later reads as an edit.
+function greens_reached(
+	hunks: ReadonlyArray<Hunk>,
+	verdicts: ReadonlyArray<string | undefined>,
+): Array<Hunk> {
+	return hunks.filter((hunk, index) => verdicts[index] === 'green' && is_line_hunk(hunk))
+}
+
+function record_of(hunk: Hunk): GreenHunk {
+	return { file: hunk.file, old_lines: hunk.old_lines, new_lines: hunk.new_lines ?? [] }
+}
+
+// Every line of `part` sits in `whole`, in the same order.
+function is_subsequence(part: ReadonlyArray<string>, whole: ReadonlyArray<string>): boolean {
+	const remaining = [...whole]
+
+	return part.every((line) => remaining.splice(0, remaining.indexOf(line) + 1).at(-1) === line)
+}
+
+function is_same_lines(left: ReadonlyArray<string>, right: ReadonlyArray<string>): boolean {
+	return JSON.stringify(left) === JSON.stringify(right)
+}
+
+// `hunk` is `green` with none of its lines added or changed, only some — or none — removed.
+function is_remnant(hunk: Hunk, green: GreenHunk): boolean {
+	if (!is_line_hunk(hunk) || hunk.file !== green.file) return false
+
+	return (
+		is_same_lines(hunk.old_lines, green.old_lines) &&
+		is_subsequence(hunk.new_lines ?? [], green.new_lines)
+	)
+}
+
+// `content` with each of `hunks` reverted, the lowest last so a revert moves none still to come.
+function reverted(content: string, hunks: ReadonlyArray<Hunk>): string {
+	const order = hunks.toSorted((left, right) => right.new_start - left.new_start)
+	let text = content
+
+	for (const hunk of order) {
+		text = test_pinned_logic.revert(text, hunk)
+	}
+
+	return text
+}
+
+// The hunks a later run reverts: each one that is only what is left of a recorded `green` hunk.
+function remnants_of(hunks: ReadonlyArray<Hunk>, greens: ReadonlyArray<GreenHunk>): Array<Hunk> {
+	return hunks.filter((hunk) => greens.some((green) => is_remnant(hunk, green)))
+}
+
+// The digest of each `green` hunk's file now, with `reverts` reverted; a file the work tree no longer
+// holds has none.
+function pruned_digests(
+	contents: ReadonlyMap<string, string>,
+	reverts: ReadonlyArray<Hunk>,
+	greens: ReadonlyArray<GreenHunk>,
+): Map<string, string> {
+	const files = [...new Set(greens.map((green) => green.file))]
+	const pairs = files.flatMap((file) => {
+		const content = contents.get(file)
+		if (content === undefined) return []
+		const own = reverts.filter((hunk) => hunk.file === file)
+
+		return [[file, test_pinned_cache_logic.digest_of(reverted(content, own))] as const]
+	})
+
+	return new Map(pairs)
+}
+
+// The code change with `reverts` reverted. Each `green` file is listed whether or not it still differs
+// from the base, so one a removal put back reads the same as one a revert did.
+function pruned_of(
+	code: CodeChange,
+	contents: ReadonlyMap<string, string>,
+	reverts: ReadonlyArray<Hunk>,
+	greens: ReadonlyArray<GreenHunk>,
+): string {
+	const pruned = pruned_digests(contents, reverts, greens)
+	const digests = new Map([...code.digests, ...pruned])
+	const paths = [...new Set([...code.code, ...pruned.keys()])]
+
+	return test_pinned_cache_logic.change_of(code.commit, paths, digests)
+}
+
+const test_pinned_prune_logic = { greens_reached, record_of, is_remnant, remnants_of, pruned_of }
+
+export type { CodeChange }
+export { test_pinned_prune_logic }