@joshuafolkken/kit 1.2116.0 → 1.3041.0

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

@@ -4,10 +4,16 @@ 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_ledger,
+	type PinnedOrigin,
+	type ProbeTime,
+	type Skipped,
+} 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_pinned_type_check } from './test-pinned-type-check'
 import { test_red } from './test-red'
 import type { RedProbe } from './test-red-logic'
 import { related_scope, type RelatedScope } from './test-related-scope'
@@ -21,7 +27,7 @@ import { unit_worker_share } from './unit-worker-share'
 // 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`).
+// is wide (`test-pinned-stage.ts`), type-checked between the stages (`test-pinned-type-check.ts`).
 
 const TREE_PREFIX = 'josh-test-pinned-'
 const HEAD = 'HEAD'
@@ -34,6 +40,7 @@ interface Probe {
 	index: number
 	recheck?: Recheck | undefined
 	reach?: number | undefined
+	spawned?: ReadonlyArray<string> | undefined
 }
 
 type OnVerdict = (index: number, verdict: RedProbe) => Promise<void>
@@ -47,7 +54,7 @@ async function direct_of(root: string, file: string): Promise<Array<string>> {
 // 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> {
+async function import_plan(root: string, probe: Probe): Promise<StagePlan> {
 	const { file } = probe.hunk
 
 	if (direct_importers.every_test_imports_of([file]).length > 0) {
@@ -59,6 +66,17 @@ async function plan_of(root: string, probe: Probe): Promise<StagePlan> {
 	return test_pinned_stage.plan_over(file, await direct_of(root, file), probe.reach)
 }
 
+async function plan_of(root: string, probe: Probe): Promise<StagePlan> {
+	const plan = await import_plan(root, probe)
+	const spawned = probe.spawned ?? []
+
+	return {
+		...plan,
+		direct: plan.direct?.concat(spawned),
+		reach: [...new Set([...plan.reach, ...spawned])],
+	}
+}
+
 // 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(
@@ -95,27 +113,40 @@ async function selection_of(
 	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
+// `action` 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
-
+async function with_revert<T>(tree: BaseTree, hunk: Hunk, action: () => Promise<T>): Promise<T> {
 	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)
+		return await action()
 	} finally {
 		await writeFile(target, content)
 	}
 }
 
+async function reverted_run(
+	tree: BaseTree,
+	hunk: Hunk,
+	selection: ReadonlyArray<string> | undefined,
+): Promise<RedProbe> {
+	if (selection === undefined) return NO_TEST
+
+	return await with_revert(tree, hunk, async () => await test_red.probe_in(tree, selection))
+}
+
+// Whether the type check over the hunk's file and its direct importers reads red with it reverted and
+// green without: a scope already red before the revert answers nothing.
+async function is_reverted_type_red(tree: BaseTree, hunk: Hunk): Promise<boolean> {
+	const scope = await test_pinned_type_check.scope_of(hunk.file)
+	if (scope.length === 0 || (await test_pinned_type_check.is_red(tree, scope))) return false
+
+	return await with_revert(tree, hunk, async () => await test_pinned_type_check.is_red(tree, scope))
+}
+
 // 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 {
@@ -140,7 +171,11 @@ async function fresh_verdict(tree: BaseTree, probe: Probe, lane: Lane): Promise<
 		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)
+	async function is_type_red(): Promise<boolean> {
+		return await is_reverted_type_red(tree, probe.hunk)
+	}
+
+	return await test_pinned_stage.staged_verdict(plan, run, is_type_red, lane.staged)
 }
 
 // The hunk's verdict: its recheck's answer, or a fresh probe where it answers none.
@@ -212,10 +247,12 @@ async function pooled(
 }
 
 // `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.
+// (`test-pinned-rewire.ts`), `over_cap` the ones over the test-file cap; `is_first_unpinned` starts
+// no probe once one is unpinned.
 interface CheckOptions {
 	held?: number
 	rewired?: number
+	over_cap?: number
 	is_first_unpinned?: boolean
 	origin?: PinnedOrigin | undefined
 }
@@ -226,6 +263,15 @@ interface Checked {
 	staged: Staged
 }
 
+function skipped_of(options: CheckOptions): Skipped {
+	return {
+		held: options.held ?? 0,
+		rewired: options.rewired ?? 0,
+		over_cap: options.over_cap ?? 0,
+		origin: options.origin,
+	}
+}
+
 // 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.
@@ -241,9 +287,7 @@ async function checked_on(
 	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)
+	await test_pinned_ledger.record(skipped_of(options), times, Date.now() - started)
 
 	return { verdicts, staged }
 }

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

@@ -24,7 +24,8 @@ interface CodeChange {
 
 // 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
+	// A green move proves only its joint revert, never either end on its own.
+	return hunk.function_name === undefined && hunk.parts === undefined
 }
 
 // The line hunks whose verdict is `green` — the ones the cache records, and the only ones its `pruned`

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

@@ -22,6 +22,7 @@ const FIXTURE_MARK = '-fixture'
 // `related` names the tests reaching a file, which `test-pinned-cache-logic.ts` turns into a basis.
 interface Reach {
 	related: (file: string) => Promise<Array<string> | undefined>
+	spawned: (file: string) => Promise<Array<string> | undefined>
 	failed: (tests: ReadonlyArray<string>) => Promise<string | undefined>
 }
 
@@ -113,11 +114,11 @@ async function probed_files(files: ReadonlyArray<string>): Promise<Array<string>
 	return files.filter((file) => !is_fixture(file) || is_asset(view, file))
 }
 
-// The test files whose runtime imports reach `file` — the graph vitest walks (joshuafolkken/kit#5368).
+// The tests whose runtime imports or spawned entries reach `file` (joshuafolkken/kit#5368, #6433).
 function related_of(view: GraphView, file: string): Array<string> {
 	const reached = view.graph.runtime_importers([path.resolve(file)], view.universe)
 
-	return [...reached]
+	return [...new Set([...reached, ...view.spawn.related(path.resolve(file))])]
 		.map((reader) => path.relative(process.cwd(), reader))
 		.filter((reader) => test_declared_logic.is_test_file(reader))
 }
@@ -178,7 +179,14 @@ function create(inputs: ReachInputs): Reach {
 		return read === undefined ? undefined : failed_of(read, tests, inputs)
 	}
 
-	return { related, failed }
+	async function spawned(file: string): Promise<Array<string> | undefined> {
+		held.view ??= view_of()
+		const read = await held.view
+
+		return read?.spawn.related(path.resolve(file)).map((test) => path.relative(process.cwd(), test))
+	}
+
+	return { related, failed, spawned }
 }
 
 const test_pinned_reach = {

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

@@ -5,6 +5,7 @@ import { stamp_file } from '#scripts/josh/stamp-file'
 import { test_pinned_cache_logic } from './test-pinned-cache-logic'
 import type { PinnedOrigin } from './test-pinned-ledger'
 import { test_pinned_logic, type PinnedReport, type ReportParts } from './test-pinned-logic'
+import { test_pinned_snapshot } from './test-pinned-snapshot'
 
 // The answer `josh test:pinned --record` leaves for `josh run:review --join` (joshuafolkken/kit#4770):
 // the printed report and its unpinned count, keyed to the checkout. `run:review` starts the check in
@@ -23,6 +24,8 @@ const FIRST_UNPINNED_FLAG = '--first-unpinned'
 const LIST_PREFIX = 'josh-test-pinned-list-'
 const LIST_SUFFIX = '.log'
 const LIST_HEADER = 'josh test:pinned — every unpinned and unchecked place'
+const UNCHECKED_NOTE =
+	'Unchecked places are not verified: map each listed place to its related regression test before ship; reuse the pending probe or cached verdicts, and fix unresolved places with the round-1 findings.\n'
 
 type UnpinnedHunk = PinnedReport['unpinned'][number]
 
@@ -31,6 +34,7 @@ type UnpinnedHunk = PinnedReport['unpinned'][number]
 // `text`, `counts` and `log` are the printed report's parts (`test_pinned_logic.report_text`).
 interface PinnedSummary extends ReportParts {
 	unpinned: ReadonlyArray<string>
+	is_unchecked?: boolean
 	// What a check still running reached so far; it is shown, never judged or remembered as the answer.
 	is_partial?: boolean
 	// A `--first-unpinned` check that stopped before some hunks (joshuafolkken/kit#5153): its unpinned
@@ -45,6 +49,12 @@ interface PinnedSummary extends ReportParts {
 // key (joshuafolkken/kit#4775): the file, the function, and a digest of the lines the change replaced
 // and the lines it put in their place.
 function site_of(hunk: UnpinnedHunk): string {
+	if (hunk.parts !== undefined) {
+		return stamp_file.digest(
+			JSON.stringify(hunk.parts.map((part) => site_of({ ...part, is_green: hunk.is_green }))),
+		)
+	}
+
 	const body = JSON.stringify([hunk.new_count, hunk.old_lines, hunk.new_lines ?? []])
 	const key = stamp_file.digest(body).slice(0, SITE_KEY_LENGTH)
 	const place = hunk.function_name === undefined ? hunk.file : `${hunk.file} ${hunk.function_name}`
@@ -65,6 +75,7 @@ function kept_log(report: PinnedReport, root: string): KeptLog | undefined {
 function summary_with(report: PinnedReport, log: KeptLog | undefined): PinnedSummary {
 	const summary = {
 		...test_pinned_logic.report_parts(report),
+		...(test_pinned_logic.has_unchecked(report) && { is_unchecked: true }),
 		log,
 		unpinned: test_pinned_cache_logic.distinct(report.unpinned.map((hunk) => site_of(hunk))),
 	}
@@ -83,14 +94,17 @@ function summary_of(report: PinnedReport, root: string = PROJECT_ROOT): PinnedSu
 function partial_summary(report: PinnedReport, note: string): PinnedSummary {
 	const summary = summary_with(report, undefined)
 
-	return { ...summary, text: `${note}\n${summary.text}`, is_partial: true }
+	const places = test_pinned_logic.format(report)
+	const next = summary.is_unchecked === true ? UNCHECKED_NOTE : ''
+
+	return { ...summary, text: `${note}\n${places}\n${next}`, is_partial: true }
 }
 
 // A check that could not run checked nothing, so it names no unpinned place and the run fails open.
 function not_run_summary(error: unknown): PinnedSummary {
 	const message = error instanceof Error ? error.message : String(error)
 
-	return { text: `${NOT_RUN_NOTE}${message}\n`, unpinned: [] }
+	return { text: `${NOT_RUN_NOTE}${message}\n`, unpinned: [], is_unchecked: true }
 }
 
 function record_path(token: string, root: string = PROJECT_ROOT): string {
@@ -129,11 +143,16 @@ function remaining_of(record: Record<string, unknown>): Pick<PinnedSummary, 'rem
 	return typeof remaining === 'number' ? { remaining } : {}
 }
 
+function snapshot_of(record: Record<string, unknown>): Pick<PinnedSummary, 'tree_hash'> {
+	return typeof record['tree_hash'] === 'string' ? { tree_hash: record['tree_hash'] } : {}
+}
+
 function to_summary(record: Record<string, unknown>): PinnedSummary | undefined {
 	const { text, unpinned, is_cut } = record
 
 	if (typeof text !== 'string' || !is_text_list(unpinned)) return undefined
-	const summary = { text, unpinned, ...tail_of(record) }
+	const unchecked = record['is_unchecked'] === true ? { is_unchecked: true } : {}
+	const summary = { text, unpinned, ...tail_of(record), ...unchecked, ...snapshot_of(record) }
 
 	return is_cut === true ? { ...summary, is_cut, ...remaining_of(record) } : summary
 }
@@ -150,7 +169,7 @@ function parsed(raw: string): Record<string, unknown> | undefined {
 	}
 }
 
-function read(token: string, root: string = PROJECT_ROOT): PinnedSummary | undefined {
+function read_summary(token: string, root: string): PinnedSummary | undefined {
 	const raw = stamp_file.read_stamp_text(record_path(token, root))
 	const record = raw === undefined ? undefined : parsed(raw)
 
@@ -159,6 +178,18 @@ function read(token: string, root: string = PROJECT_ROOT): PinnedSummary | undef
 	return to_summary(record)
 }
 
+function fresh_summary(summary: PinnedSummary, root: string): PinnedSummary {
+	if (summary.tree_hash === undefined) return summary
+
+	return { ...summary, is_stale: test_pinned_snapshot.current_hash(root) !== summary.tree_hash }
+}
+
+function read(token: string, root: string = PROJECT_ROOT): PinnedSummary | undefined {
+	const summary = read_summary(token, root)
+
+	return summary === undefined ? undefined : fresh_summary(summary, root)
+}
+
 function clear(token: string, root: string = PROJECT_ROOT): void {
 	stamp_file.remove_stamp(record_path(token, root))
 }
@@ -180,6 +211,7 @@ function launch_argv(
 }
 
 const test_pinned_record = {
+	UNCHECKED_NOTE,
 	clear,
 	launch_argv,
 	is_text_list,

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

@@ -0,0 +1,110 @@
+import { existsSync } from 'node:fs'
+import { rm } from 'node:fs/promises'
+import path from 'node:path'
+import { input_fingerprint } from '#scripts/gate/input-fingerprint'
+import { base_tree } from '#scripts/git/base-tree'
+import { changed_paths } from '#scripts/git/changed-paths'
+import { git_spawn_sync, type GitSyncOptions } from '#scripts/git/git-spawn-sync'
+
+const PREFIX = 'josh-pinned-snapshot-'
+const CACHE_NAME = 'josh-test-pinned-verdicts.json'
+const IDENTITY = ['-c', 'user.name=Snapshot', '-c', 'user.email=snapshot@localhost']
+
+interface Snapshot {
+	head: string
+	tree: string
+	tree_hash: string
+	cache_file: string
+}
+
+function read(args: ReadonlyArray<string>, options: GitSyncOptions): string {
+	const result = git_spawn_sync.run(args, options)
+	if (result.exit_code !== 0) throw new Error(`Snapshot git failed: ${result.stderr}`)
+
+	return result.stdout.trimEnd()
+}
+
+function identity(root: string, head: string, index: string): string {
+	const tracked = read(['diff', '--name-only', '-z', head, '--'], { cwd: root })
+	const untracked = read(['ls-files', '--others', '--exclude-standard', '-z'], { cwd: root })
+	const paths = `${tracked}\0${untracked}`.split('\0').filter((file) => file !== '')
+	const contents = input_fingerprint.of_files(root, paths)
+
+	return input_fingerprint.of_entries([head, index, JSON.stringify(contents)])
+}
+
+function current_hash(root: string): string | undefined {
+	try {
+		return identity(
+			root,
+			read(['rev-parse', 'HEAD'], { cwd: root }),
+			read(['ls-files', '--stage', '-z'], { cwd: root }),
+		)
+	} catch {
+		return undefined
+	}
+}
+
+async function in_tree<T>(tree: string, action: () => Promise<T>): Promise<T> {
+	const original = process.cwd()
+
+	process.chdir(tree)
+
+	try {
+		return await action()
+	} finally {
+		process.chdir(original)
+	}
+}
+
+async function copy_changes(tree: string, head: string): Promise<void> {
+	const paths = await changed_paths.read_changed_since(head)
+	const present = paths.filter((file) => existsSync(file))
+	const deleted = paths.filter((file) => !existsSync(file))
+
+	await base_tree.copy_in(tree, present)
+	await Promise.all(
+		deleted.map(async (file) => {
+			await rm(path.join(tree, file), { force: true })
+		}),
+	)
+	if (present.length > 0) read(['add', '--force', '--', ...present], { cwd: tree })
+}
+
+// Only the disposable worktree's index and HEAD are written. Its commit freezes every probe copy;
+// the original index (including partial staging or conflicts) contributes only to the identity.
+function seal(root: string, head: string, index: string, cache_file: string): Snapshot {
+	const tree_hash = identity(root, head, index)
+
+	read(['add', '--all'], { cwd: root })
+	const tree = read(['write-tree'], { cwd: root })
+	const commit = read([...IDENTITY, 'commit-tree', tree, '-p', head, '-m', 'Pinned snapshot'], {
+		cwd: root,
+	})
+
+	read(['update-ref', 'HEAD', commit], { cwd: root })
+
+	return { head, tree, tree_hash, cache_file }
+}
+
+async function with_snapshot<T>(action: (snapshot: Snapshot) => Promise<T>): Promise<T> {
+	const root = process.cwd()
+	const head = read(['rev-parse', 'HEAD'], { cwd: root })
+	const index = read(['ls-files', '--stage', '-z'], { cwd: root })
+	const cache_file = path.resolve(
+		root,
+		read(['rev-parse', '--git-path', CACHE_NAME], { cwd: root }),
+	)
+
+	return await base_tree.with_tree(PREFIX, head, async (tree) => {
+		await copy_changes(tree.tree, head)
+		const snapshot = seal(tree.tree, head, index, cache_file)
+
+		return await in_tree(tree.tree, async () => await action(snapshot))
+	})
+}
+
+const test_pinned_snapshot = { current_hash, with_snapshot }
+
+export type { Snapshot }
+export { test_pinned_snapshot }

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

@@ -2,10 +2,13 @@ import path from 'node:path'
 import type { ImportGraph } from '#scripts/lint/import-graph'
 import { test_declared_logic } from './test-declared-logic'
 
-// The code a failed test can run past its import closure (joshuafolkken/kit#5261): a test starts a CLI
+// The code a test can run past its import closure (joshuafolkken/kit#5261, joshuafolkken/kit#6433): a test starts a CLI
 // by naming its file in a string, so a file a string literal of the test or of a module it imports
 // names is one it may start, and so is a file the strings that one runs name in turn — the command a
-// spawned dispatcher starts by its path. Only these, with their closures, are what a `josh
+// spawned dispatcher starts by its path. The reverse lookup selects native entries named directly
+// by a test, with their runtime imports. Import closures can name distribution assets rather than
+// executions, so only the conservative red basis follows their strings. These, with their closures,
+// are what a `josh
 // test:pinned` red rests on besides the test's own closure; an edit to code nothing named reaches
 // leaves the red held. A comment starts nothing, so its file names are not read.
 //
@@ -17,6 +20,7 @@ const TOKEN = /[\w.-]+/gu
 
 interface TestSpawn {
 	started: (tests: ReadonlyArray<string>) => ReadonlySet<string>
+	related: (file: string) => ReadonlyArray<string>
 }
 
 // Each non-test code file of `universe` under its base name.
@@ -50,13 +54,34 @@ function memoized(read: (file: string) => Array<string>): (file: string) => Arra
 	}
 }
 
-function create(graph: ImportGraph, universe: ReadonlyArray<string>): TestSpawn {
-	const index = index_of(universe)
-	const names_of = memoized((file) => names_in(graph.strings(file).join(' '), index))
+function reader_of(
+	graph: ImportGraph,
+	names_of: (file: string) => Array<string>,
+): (file: string) => Array<string> {
 	// What `file` runs names: its own strings and those of every module its imports reach.
-	const named_from = memoized((file) => [
+	return memoized((file) => [
 		...new Set([file, ...graph.closure(file)].flatMap((read) => names_of(read))),
 	])
+}
+
+function reverse_of(
+	graph: ImportGraph,
+	universe: ReadonlyArray<string>,
+	names_of: (file: string) => Array<string>,
+): TestSpawn['related'] {
+	const tests = universe.filter((file) => test_declared_logic.is_test_file(file))
+
+	return function related(file: string): ReadonlyArray<string> {
+		const importers = graph.runtime_importers([file], universe)
+
+		return tests.filter((test) => names_of(test).some((entry) => importers.has(entry)))
+	}
+}
+
+function create(graph: ImportGraph, universe: ReadonlyArray<string>): TestSpawn {
+	const index = index_of(universe)
+	const names_of = memoized((file) => names_in(graph.strings(file).join(' '), index))
+	const named_from = reader_of(graph, names_of)
 
 	function started(tests: ReadonlyArray<string>): ReadonlySet<string> {
 		const found = new Set<string>()
@@ -72,7 +97,7 @@ function create(graph: ImportGraph, universe: ReadonlyArray<string>): TestSpawn
 		return found
 	}
 
-	return { started }
+	return { started, related: reverse_of(graph, universe, names_of) }
 }
 
 const test_pinned_spawn = { create }

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

@@ -3,12 +3,15 @@ import type { RedProbe } from './test-red-logic'
 // The stages of one `josh test:pinned` probe (joshuafolkken/kit#5292): a hunk whose file reaches far
 // more test files than import it directly runs those importers first, since a revert's red almost
 // always lands there, and the whole reach only when they do not go red. A narrow file runs its reach
-// once, as before.
+// once, as before. Between the two, the hunk is type-checked with it reverted (joshuafolkken/kit#5385):
+// a change only the types pin reads red there, so the whole reach is run only when that is green too.
 
 // A reach of this many test files is wide whatever the direct importers number.
 const WIDE_REACH = 100
 // A reach this many times the direct importers is wide.
 const WIDE_RATIO = 3
+// A red the type check reached: no test file failed, so none is named.
+const TYPE_RED: RedProbe = { verdict: 'red', failed: [], pinned_by: 'type-check' }
 
 // What a fresh probe runs: `direct` first where the reach is wide, then `reach` unless `direct` went red.
 interface StagePlan {
@@ -16,16 +19,20 @@ interface StagePlan {
 	reach: ReadonlyArray<string>
 }
 
-// How many probes the direct importers decided, and how many escalated to the whole reach.
+// How many probes the direct importers decided, how many the type check, and how many escalated to the
+// whole reach.
 interface Staged {
 	direct: number
+	typed: number
 	escalated: number
 }
 
 type StageRun = (files: ReadonlyArray<string>) => Promise<RedProbe>
+// Whether the type check reads red with the hunk reverted.
+type TypeRun = () => Promise<boolean>
 
 function none(): Staged {
-	return { direct: 0, escalated: 0 }
+	return { direct: 0, typed: 0, escalated: 0 }
 }
 
 // No direct importer, or as many as the reach, leaves no smaller first stage to run.
@@ -40,16 +47,17 @@ function plan_over(file: string, direct: ReadonlyArray<string>, reach: number):
 	return is_wide(reach, direct.length) ? { direct, reach: [file] } : { reach: [file] }
 }
 
-// The verdict over `plan`, each stage run through `run` and tallied into `staged`: a red from the
-// direct importers decides, anything else is answered by the whole reach.
-async function staged_verdict(plan: StagePlan, run: StageRun, staged: Staged): Promise<RedProbe> {
-	if (plan.direct === undefined) return await run(plan.reach)
-	const first = await run(plan.direct)
-
-	if (first.verdict === 'red') {
-		staged.direct += 1
-
-		return first
+// What follows a direct stage that did not go red: the type check's red, or the whole reach.
+async function past_direct(
+	plan: StagePlan,
+	run: StageRun,
+	is_type_red: TypeRun,
+	staged: Staged,
+): Promise<RedProbe> {
+	if (await is_type_red()) {
+		staged.typed += 1
+
+		return TYPE_RED
 	}
 
 	staged.escalated += 1
@@ -57,14 +65,33 @@ async function staged_verdict(plan: StagePlan, run: StageRun, staged: Staged): P
 	return await run(plan.reach)
 }
 
+// The verdict over `plan`, each stage run through `run` or `is_type_red` and tallied into `staged`: a red
+// from the direct importers decides, then a red from the type check, and anything else is answered by
+// the whole reach.
+async function staged_verdict(
+	plan: StagePlan,
+	run: StageRun,
+	is_type_red: TypeRun,
+	staged: Staged,
+): Promise<RedProbe> {
+	if (plan.direct === undefined) return await run(plan.reach)
+	const first = await run(plan.direct)
+
+	if (first.verdict !== 'red') return await past_direct(plan, run, is_type_red, staged)
+	staged.direct += 1
+
+	return first
+}
+
 // The counts line's tail, empty when no probe ran in stages.
 function counts_suffix(staged: Staged | undefined): string {
-	if (staged === undefined || staged.direct + staged.escalated === 0) return ''
+	if (staged === undefined || staged.direct + staged.typed + staged.escalated === 0) return ''
+	const typed = staged.typed === 0 ? '' : ` · type check ${String(staged.typed)}`
 
-	return ` · direct ${String(staged.direct)} · escalated ${String(staged.escalated)}`
+	return ` · direct ${String(staged.direct)}${typed} · escalated ${String(staged.escalated)}`
 }
 
 const test_pinned_stage = { WIDE_RATIO, WIDE_REACH, counts_suffix, none, plan_over, staged_verdict }
 
-export type { Staged, StagePlan }
+export type { Staged, StagePlan, TypeRun }
 export { test_pinned_stage }