@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -0,0 +1,139 @@
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import type { TestRelatedRecord } from '#scripts/lane/lane-ledger-schema'
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
+import { related_scope, type RelatedScope } from './test-related-scope'
+import { unit_count_file } from './unit-count-file'
+
+// What one `josh test:related` run leaves in the lane ledger (joshuafolkken/kit#4465): how much of its
+// input was the change itself, what a main sync brought in and what the test-read map added, the
+// scope it settled on, how many test files vitest ran and how long it took — so `josh lane:stats`
+// can tell a run widened by its input from one vitest widened by itself.
+
+const COUNT_FILE_NAME = 'count'
+
+// The facts the run knew before vitest started: the scope, and the change it was resolved from.
+interface RunInput {
+	scope: RelatedScope
+	root: string
+	// Repository-root-relative, as the change was read; `undefined` when it could not be.
+	changed: ReadonlyArray<string> | undefined
+	// The part of `changed` a main sync brought in, empty outside a since-green reading.
+	synced: ReadonlyArray<string>
+	// The part of `changed` the change since the test-read map's tree joined to the named or moved
+	// files — main merges that landed after the map among them. A file of `branch` in it counts as
+	// `changed`; it holds the synced non-code files as well, which the record counts as `synced` alone.
+	since_map: ReadonlyArray<string>
+	// This branch's own change from its merge base, where it was read.
+	branch?: ReadonlyArray<string> | undefined
+	// The name the run is recorded under when it is not the scope's own — `touched` for a `--touched` run.
+	kind?: string
+}
+
+interface RunResult {
+	elapsed_ms: number
+	test_files: number | undefined
+}
+
+function set_count_target(target: string | undefined): void {
+	const { COUNT_FILE_ENVIRONMENT } = unit_count_file
+
+	if (target === undefined) Reflect.deleteProperty(process.env, COUNT_FILE_ENVIRONMENT)
+	else process.env[COUNT_FILE_ENVIRONMENT] = target
+}
+
+// An unwritable temp root leaves the run uncounted rather than failing the tests it would only measure.
+function count_directory(): string | undefined {
+	try {
+		return mkdtempSync(path.join(tmpdir(), 'josh-test-related-'))
+	} catch {
+		return undefined
+	}
+}
+
+// Runs `run` with the unit reporter told where to write the run's test-file count, and reads it back.
+// A run that started no vitest writes none, which is an absent count rather than zero.
+async function with_test_count(
+	run: () => Promise<number>,
+): Promise<{ exit_code: number; test_files: number | undefined }> {
+	const directory = count_directory()
+
+	if (directory === undefined) return { exit_code: await run(), test_files: undefined }
+
+	const file = path.join(directory, COUNT_FILE_NAME)
+	const previous = process.env[unit_count_file.COUNT_FILE_ENVIRONMENT]
+
+	set_count_target(file)
+
+	try {
+		return { exit_code: await run(), test_files: unit_count_file.read_count(file) }
+	} finally {
+		set_count_target(previous)
+		rmSync(directory, { recursive: true, force: true })
+	}
+}
+
+// The scope's files the record counted in no part — the map's readers.
+function readers_of(input: RunInput, counted: ReadonlySet<string>): number {
+	if (input.scope.mode !== 'related') return 0
+
+	return input.scope.files.filter((file) => !counted.has(path.relative(input.root, file))).length
+}
+
+// The changed files that sent a full-suite run there, repository-root-relative, or none.
+function triggers_of(input: RunInput): Partial<TestRelatedRecord> {
+	if (input.scope.mode !== 'all' || input.scope.files.length === 0) return {}
+
+	return { trigger_files: input.scope.files.map((file) => path.relative(input.root, file)) }
+}
+
+// **The run's own change is the branch's, where it was read** (joshuafolkken/kit#5041): a synced file
+// the split cannot vouch for is in `changed` without being this branch's change. Unread, it is what
+// neither a main sync nor the map's tree joined.
+function own_of(input: RunInput): ReadonlyArray<string> {
+	const { changed = [], branch } = input
+	const joined = new Set([...input.synced, ...input.since_map])
+
+	return changed.filter((file) => branch?.includes(file) ?? !joined.has(file))
+}
+
+// The input split into its counted parts, each file in one. A synced non-code file is in `since_map`
+// too (`synced_data` in `test-related.ts`), counted as synced alone.
+function parts_of(input: RunInput): Record<'own' | 'synced' | 'since_map', ReadonlyArray<string>> {
+	const own = own_of(input)
+	const rest = (input.changed ?? []).filter((file) => !own.includes(file))
+
+	return {
+		own,
+		synced: rest.filter((file) => input.synced.includes(file)),
+		since_map: rest.filter(
+			(file) => input.since_map.includes(file) && !input.synced.includes(file),
+		),
+	}
+}
+
+function record_of(input: RunInput, result: RunResult): TestRelatedRecord {
+	const { own, synced, since_map } = parts_of(input)
+	const record = {
+		scope: input.kind ?? related_scope.scope_kind(input.scope),
+		changed: own.length,
+		synced: synced.length,
+		since_map: since_map.length,
+		readers: readers_of(input, new Set([...own, ...synced, ...since_map])),
+		...triggers_of(input),
+		elapsed_ms: Math.round(result.elapsed_ms),
+	}
+
+	return result.test_files === undefined ? record : { ...record, test_files: result.test_files }
+}
+
+// Best-effort, as every ledger write is.
+async function record_run(input: RunInput, result: RunResult, ledger?: string): Promise<void> {
+	await lane_ledger_write.record_test_related(record_of(input, result), ledger)
+}
+
+const test_related_record = { record_of, record_run, with_test_count }
+
+export type { RunInput, RunResult }
+export { test_related_record }

package/scripts/test/test-related-scope.ts

@@ -1,31 +1,43 @@
 import path from 'node:path'
-import {
-	changed_file_scope,
-	type ChangedFileScope,
-	type ScopeInputs,
-	type ScopeVocabulary,
-} from '#scripts/git/changed-file-scope'
-
-// The whole unit suite is expensive. Measured warm on kit, that is 384 files
-// and 6,616 tests — 13.9s wall and 110s of CPU, 84% of everything the four gate checks spend, and
-// an implementation loop paid it again on every re-check. The same tree narrowed to one changed
-// file runs 31 files and 566 tests in 2.4s (7.9s of CPU, −93%).
+import { since_green } from '#scripts/gate/since-green'
+import { changed_file_scope, type ChangedFileScope } from '#scripts/git/changed-file-scope'
+import { pure_files_entries } from './pure-files-entries'
+import { test_read_map, type ReadMap } from './test-read-map'
+import { whole_suite_files } from './whole-suite-files'
+
+// The whole unit suite is expensive — the largest share of what the gate checks spend, and an
+// implementation loop paid it again on every re-check — while one changed file narrows it to a small
+// fraction. `josh lane:stats` reports what `test:unit` costs now.
 //
-// **This narrowing is added in front of the whole suite, never in place of it.** A test that breaks
-// without importing what changed — a marker suite reading a document, a fixture compared against a
-// generated file — is invisible to a module graph, so the verification gate keeps running
-// `josh test:unit` over everything before the commit.
+// **The verification gate runs this narrowing in place of the whole suite** (joshuafolkken/kit#4065),
+// which is safe only because it reaches every test a change can break. A changed module reaches
+// the tests importing it through `vitest related`, and the tests reading it as data through the
+// test-read map a whole-suite run records (`test-read-map.ts`). A changed document, config or
+// snapshot — which no module graph holds — reaches the modules that read it through that map alone. **Whatever neither can answer runs the whole suite**: no map, a
+// non-code file added since the recorded tree that no recorded test read, where a test read inside its
+// directory, or a file every test
+// depends on — each counted only when this change moved it (joshuafolkken/kit#4527). A non-code file the recorded tree already held and no test read is one no test reads
+// (joshuafolkken/kit#4073), and so is one added since to a directory no test read inside
+// (joshuafolkken/kit#4303, joshuafolkken/kit#4597), so a change made only of those runs nothing. CI runs the whole suite
+// regardless, so a read the recorder could not see — one a child process makes — is still caught
+// before the merge.
 //
-// The decision this file makes is which extensions vitest can walk a module graph back from, and
-// what to print about it. Everything the decision shares with `josh lint:related` — reading the
-// change, dropping what the tree no longer holds, and the two fallbacks — is
-// `changed-file-scope.ts`, so the two commands cannot drift apart about what "changed" means.
+// Everything the decision shares with `josh lint:related` — the fallback line, the file listing and
+// the unreadable-change reason — is `changed-file-scope.ts`, so the two commands cannot drift apart
+// about what they print.
+
+// The third answer only this command has: the change is known to reach no test, so nothing runs.
+// `files` holds the changed files that settled it, for the line that says why.
+interface NoTestScope {
+	mode: 'none'
+	files: ReadonlyArray<string>
+	reason: string
+}
 
-type RelatedScope = ChangedFileScope
+type RelatedScope = ChangedFileScope | NoTestScope
 
-// The extensions vitest can walk a module graph back from. A changed `.md`, `.yaml` or `.json` is
-// dropped rather than passed through: `vitest related` would match no test file for it, and a run
-// narrowed to nothing at all is the one outcome this module exists to prevent.
+// The extensions vitest can walk a module graph back from. Every other changed file is resolved
+// through the test-read map instead.
 const RELATABLE_EXTENSIONS: ReadonlySet<string> = new Set([
 	'.ts',
 	'.tsx',
@@ -38,8 +50,24 @@ const RELATABLE_EXTENSIONS: ReadonlySet<string> = new Set([
 	'.svelte',
 ])
 
+const { WHOLE_SUITE_FILES } = whole_suite_files
 const { UNREADABLE_REASON } = changed_file_scope
-const NOTHING_RELATABLE_REASON = 'no changed file is one a test can import'
+const NOTHING_RELATABLE_REASON = 'no changed file is one a test can import or read'
+const NO_MAP_REASON = 'no test-read map covers the changed non-code file'
+const { UNMOVED_REASON } = since_green
+const WHOLE_SUITE_SUFFIX = 'affects every test'
+const UNRECORDED_SUFFIX = 'is read by no recorded test'
+
+// The stable kind each full-suite reason falls under, so the gate ledger counts the fallbacks by why
+// rather than by the file a reason names (joshuafolkken/kit#4397).
+const FALLBACK_KINDS: ReadonlyArray<{ kind: string; reason: string }> = [
+	{ kind: 'unreadable', reason: UNREADABLE_REASON },
+	{ kind: 'nothing-relatable', reason: NOTHING_RELATABLE_REASON },
+	{ kind: 'no-map', reason: NO_MAP_REASON },
+	{ kind: 'whole-suite-file', reason: WHOLE_SUITE_SUFFIX },
+	{ kind: 'unrecorded-file', reason: UNRECORDED_SUFFIX },
+]
+const OTHER_FALLBACK = 'other'
 
 // The command this narrowing belongs to, defined once: the guard prints it when it skips, and the
 // line below prints it in front of every decision.
@@ -47,42 +75,261 @@ const COMMAND_NAME = 'test:related'
 const COMMAND_LABEL = `josh ${COMMAND_NAME}`
 const { LISTED_FILE_LIMIT } = changed_file_scope
 
-const VOCABULARY: ScopeVocabulary = {
+const VOCABULARY = {
 	label: COMMAND_LABEL,
 	fallback_suffix: 'running the full unit suite instead',
 	narrowed_suffix: 'running only the tests related to them',
 }
 
+const NONE_SUFFIX = 'running no tests'
+
 const RUN_FLAG = '--run'
 const RELATED_SUBCOMMAND = 'related'
 const RUN_SUBCOMMAND = 'run'
 
+// Bundled so the CLI and the tests hand the decision the same five facts.
+interface ScopeRequest {
+	root: string
+	// Repository-root-relative paths, or `undefined` when the change could not be read.
+	changed: ReadonlyArray<string> | undefined
+	map: ReadMap | undefined
+	// The changed non-code files the map's tree held, and that did not differ from it when the map
+	// was recorded — the ones whose having no reader in the map means no test reads them.
+	recorded: ReadonlySet<string>
+	is_present: (file_path: string) => boolean
+	// The part of `changed` that joined only because it differs from the map's tree — which another
+	// lane's branch records — not because this change moved it. Only a code file of it naming a moved
+	// file reaches vitest; the rest — its non-code files' readers among it — never runs a test nor sends
+	// the run to the whole suite: this tree verified it already, or main's CI did
+	// (joshuafolkken/kit#4527, joshuafolkken/kit#4896).
+	since_map?: ReadonlyArray<string>
+	// The code files of `since_map` that name a file this change moved — the only ones of that part
+	// handed to vitest (joshuafolkken/kit#4532). See `is_code_input`.
+	naming_moved?: ReadonlySet<string>
+	// The entries a change of `tools/test/pure-files.ts` moved, when it moved nothing else there — the
+	// list then reaches those test files rather than every test (`pure-files-entries.ts`).
+	pure_entries?: ReadonlyArray<string> | undefined
+	// The changed files every test imports, each with the test files importing it directly
+	// (`direct-importers.ts`) — the run narrows to those rather than the whole suite.
+	every_test_importers?: ReadonlyMap<string, ReadonlyArray<string>>
+}
+
+// What the decision narrows to: the files to hand vitest, and the changed files known to reach no
+// test.
+interface Selection {
+	files: ReadonlyArray<string>
+	unread: ReadonlyArray<string>
+}
+
+// Either the selection the changed non-code files resolve to, or why they cannot be resolved — with
+// the repository-root-relative files that sent the run to the whole suite, where a file did.
+type MapResolution = Selection | { reason: string; triggers?: ReadonlyArray<string> }
+
 function is_relatable(file_path: string): boolean {
 	return RELATABLE_EXTENSIONS.has(path.extname(file_path))
 }
 
-// The three inputs that make the shared narrowing this command's, handed over as one value so the
-// CLI and the two functions below cannot disagree about any of them.
-function scope_inputs(is_present: (file_path: string) => boolean): ScopeInputs {
-	return { is_present, is_selectable: is_relatable, nothing_reason: NOTHING_RELATABLE_REASON }
+function is_moved(request: ScopeRequest, file: string): boolean {
+	return request.since_map?.includes(file) !== true
+}
+
+// **A code file only the map's tree differs by — another lane's change, or main's since, a test file
+// among them — is handed to vitest only when it names a file this change moved**
+// (joshuafolkken/kit#4532, joshuafolkken/kit#4896). Leaving the rest out is safe: an import of a moved
+// module is reached from that module itself, since `vitest related` walks every test file's graph
+// rather than the map's; the one read neither the graph nor the map sees is a file-system read added
+// since the map's tree, and such a read names the file it reads. A test file reaching a moved file
+// through a helper's read, or a read whose path is assembled from fragments or listed from a directory,
+// is missed here and caught by CI's whole suite before the merge, as a child process's read is.
+function is_code_input(request: ScopeRequest, file: string): boolean {
+	if (!is_relatable(file)) return false
+	if (is_moved(request, file)) return true
+
+	return request.naming_moved?.has(file) === true
+}
+
+// A full-suite scope's `files` are the changed files that sent it there (joshuafolkken/kit#4510), as a
+// `none` scope's are the ones that settled it; the printed line still names only the first.
+function all_scope(reason: string, triggers: ReadonlyArray<string> = [], root = ''): RelatedScope {
+	return { mode: 'all', files: triggers.map((file) => path.join(root, file)), reason }
 }
 
-function select_related_files(
-	paths: ReadonlyArray<string>,
-	is_present: (file_path: string) => boolean,
+// A file no recorded test read narrows only when the recorded tree held it, or no recorded test read
+// inside its directory: any other file added since is one the recorder never saw, so its having no
+// reader says nothing.
+function resolve_through_map(others: ReadonlyArray<string>, request: ScopeRequest): MapResolution {
+	const { map, recorded } = request
+
+	if (others.length === 0) return { files: [], unread: [] }
+	if (map === undefined) return { reason: `${NO_MAP_REASON} ${String(others[0])}` }
+
+	const unread = others.filter((file) => test_read_map.readers_of(map, file).length === 0)
+	const unknown = unread.filter(
+		(file) =>
+			is_moved(request, file) &&
+			!recorded.has(file) &&
+			!test_read_map.in_unread_directory(map, file),
+	)
+
+	if (unknown.length > 0) {
+		return { reason: `${String(unknown[0])} ${UNRECORDED_SUFFIX}`, triggers: unknown }
+	}
+
+	return { files: others.flatMap((file) => test_read_map.readers_of(map, file)), unread }
+}
+
+// A changed module is also data to a test that reads it through `fs` rather than importing it, and
+// `vitest related` cannot see that read. Unlike a non-code file, a module the map does not hold
+// still narrows — through the module graph alone.
+function code_readers(code: ReadonlyArray<string>, map: ReadMap | undefined): Array<string> {
+	if (map === undefined) return []
+
+	return code.flatMap((file) => test_read_map.readers_of(map, file))
+}
+
+function none_scope(unread: ReadonlyArray<string>, root: string): NoTestScope {
+	const files = unread.map((file) => path.join(root, file))
+
+	return { mode: 'none', files, reason: `${String(files.length)} changed file(s) reach no test` }
+}
+
+// Nothing to select is "no test" only when something settled it; an empty or vanished selection
+// still runs the whole suite.
+function narrowed_scope(selection: Selection, request: ScopeRequest): RelatedScope {
+	if (selection.files.length === 0 && selection.unread.length > 0) {
+		return none_scope(selection.unread, request.root)
+	}
+
+	const present = [...new Set(selection.files)]
+		.map((file) => path.join(request.root, file))
+		.filter((file) => request.is_present(file))
+
+	if (present.length === 0) return all_scope(NOTHING_RELATABLE_REASON)
+
+	return { mode: 'related', files: present, reason: `${String(present.length)} related file(s)` }
+}
+
+// The part only the map's tree differs by that reached no test — settled as surely as an unread file,
+// so a tree holding nothing of this change's own runs no test rather than the whole suite.
+function left_out(request: ScopeRequest, code: ReadonlyArray<string>): Array<string> {
+	return (request.since_map ?? []).filter((file) => !code.includes(file))
+}
+
+// The change with an entries-only `pure-files.ts` taken out of it, and the test files it reaches in
+// its place — it would send `vitest related` to every test.
+function without_pure_entries(
+	changed: ReadonlyArray<string>,
+	entries: ReadonlyArray<string> | undefined,
+): Selection {
+	if (entries === undefined) return { files: [], unread: changed }
+
+	const rest = changed.filter((file) => file !== pure_files_entries.PURE_FILES_PATH)
+
+	return { files: pure_files_entries.tests_of(entries), unread: rest }
+}
+
+function is_narrowed(request: ScopeRequest, file: string): boolean {
+	return request.every_test_importers?.has(file) === true
+}
+
+// **A moved file every test imports reaches only the test files importing it directly**
+// (joshuafolkken/kit#5122): handed to vitest it would run the whole suite, which the gate's `test:unit`
+// and CI run once regardless. One no test imports directly reaches no test here.
+function direct_selection(request: ScopeRequest, changed: ReadonlyArray<string>): Selection {
+	const moved = changed.filter((file) => is_narrowed(request, file) && is_moved(request, file))
+	const tests = moved.map((file) => request.every_test_importers?.get(file) ?? [])
+
+	return { files: tests.flat(), unread: moved.filter((_file, index) => tests[index]?.length === 0) }
+}
+
+function whole_suite_triggers(
+	request: ScopeRequest,
+	changed: ReadonlyArray<string>,
 ): Array<string> {
-	return changed_file_scope.select_files(paths, scope_inputs(is_present))
+	return changed.filter(
+		(file) => WHOLE_SUITE_FILES.has(file) && !is_narrowed(request, file) && is_moved(request, file),
+	)
 }
 
-function resolve_scope(
-	paths: ReadonlyArray<string> | undefined,
-	is_present: (file_path: string) => boolean,
+function resolve_read(
+	request: ScopeRequest & { changed: ReadonlyArray<string> },
+	entry_tests: ReadonlyArray<string>,
 ): RelatedScope {
-	return changed_file_scope.resolve_scope(paths, scope_inputs(is_present))
+	const { changed, root } = request
+	const whole = whole_suite_triggers(request, changed)
+
+	if (whole.length > 0) return all_scope(`${String(whole[0])} ${WHOLE_SUITE_SUFFIX}`, whole, root)
+
+	const direct = direct_selection(request, changed)
+	const code = changed.filter((file) => !is_narrowed(request, file) && is_code_input(request, file))
+	const resolution = resolve_through_map(
+		changed.filter((file) => !is_relatable(file) && is_moved(request, file)),
+		request,
+	)
+
+	if ('reason' in resolution) return all_scope(resolution.reason, resolution.triggers, root)
+
+	const files = [
+		...code,
+		...code_readers(code, request.map),
+		...resolution.files,
+		...entry_tests,
+		...direct.files,
+	]
+	const unread = [...resolution.unread, ...left_out(request, code), ...direct.unread]
+
+	return narrowed_scope({ files, unread }, request)
+}
+
+// `undefined` and `[]` are deliberately different inputs. The first says the change could not be
+// read; the second says it was read and held nothing to relate.
+function resolve_scope(request: ScopeRequest): RelatedScope {
+	if (request.changed === undefined) return all_scope(UNREADABLE_REASON)
+
+	const pure = without_pure_entries(request.changed, request.pure_entries)
+
+	return resolve_read({ ...request, changed: pure.unread }, pure.files)
 }
 
 function describe_scope(scope: RelatedScope, root: string): string {
-	return changed_file_scope.describe_scope(scope, root, VOCABULARY)
+	if (scope.mode !== 'none') return changed_file_scope.describe_scope(scope, root, VOCABULARY)
+
+	const listing = changed_file_scope.format_file_list(scope.files, root)
+
+	return `${COMMAND_LABEL}: ${scope.reason} — ${NONE_SUFFIX}.\n${listing}`
+}
+
+function reason_kind(reason: string): string {
+	return FALLBACK_KINDS.find((entry) => reason.includes(entry.reason))?.kind ?? OTHER_FALLBACK
+}
+
+// The kind of full-suite fallback a run's output names, read off the line `describe_scope` printed, or
+// `undefined` when the run narrowed or ran nothing.
+function fallback_kind(output: string): string | undefined {
+	const prefix = `${COMMAND_LABEL}: `
+	const suffix = ` — ${VOCABULARY.fallback_suffix}.`
+	const line = output
+		.split('\n')
+		.map((candidate) => candidate.trim())
+		.find((candidate) => candidate.startsWith(prefix) && candidate.endsWith(suffix))
+
+	if (line === undefined) return undefined
+
+	return reason_kind(line.slice(prefix.length, -suffix.length))
+}
+
+// The stable name a scope is recorded under: its mode when it narrowed or ran nothing, else the kind of
+// full-suite fallback its reason falls under (joshuafolkken/kit#4465).
+function scope_kind(scope: RelatedScope): string {
+	return scope.mode === 'all' ? reason_kind(scope.reason) : scope.mode
+}
+
+// Whether a run's output is the since-green no-op — nothing moved, so no test ran — read off the line
+// `describe_scope` printed, so the gate ledger never times it as a unit run (joshuafolkken/kit#4457).
+function is_unmoved(output: string): boolean {
+	const line = `${COMMAND_LABEL}: ${UNMOVED_REASON} — ${NONE_SUFFIX}.`
+
+	return output.split('\n').some((candidate) => candidate.trim() === line)
 }
 
 // `--run` is what keeps `vitest related` out of watch mode; the `run` sub-command already implies it
@@ -91,7 +338,7 @@ function vitest_arguments(
 	scope: RelatedScope,
 	extra_flags: ReadonlyArray<string> = [],
 ): ReadonlyArray<string> {
-	if (scope.mode === 'all') return [RUN_SUBCOMMAND, ...extra_flags]
+	if (scope.mode !== 'related') return [RUN_SUBCOMMAND, ...extra_flags]
 
 	return [RELATED_SUBCOMMAND, ...scope.files, RUN_FLAG, ...extra_flags]
 }
@@ -101,14 +348,18 @@ const related_scope = {
 	COMMAND_NAME,
 	LISTED_FILE_LIMIT,
 	NOTHING_RELATABLE_REASON,
+	NO_MAP_REASON,
+	UNMOVED_REASON,
 	UNREADABLE_REASON,
 	describe_scope,
+	fallback_kind,
 	is_relatable,
+	is_unmoved,
 	resolve_scope,
-	scope_inputs,
-	select_related_files,
+	scope_kind,
 	vitest_arguments,
 }
 
 export type { ScopeMode } from '#scripts/git/changed-file-scope'
+export type { RelatedScope, ScopeRequest }
 export { related_scope }

package/scripts/test/test-related-synced.ts

@@ -0,0 +1,135 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { import_graph, type ImportGraph } from '#scripts/lint/import-graph'
+import { test_declared_logic } from './test-declared-logic'
+import { test_pinned_reach } from './test-pinned-reach'
+import { test_read_map, type ReadMap } from './test-read-map'
+import { related_scope } from './test-related-scope'
+import { whole_suite_files } from './whole-suite-files'
+
+// **A code module a main sync brought in reaches vitest only through a test this branch's change
+// reaches too** (joshuafolkken/kit#4912). Handed to `vitest related` as a moved file, such a module ran
+// every test importing it, and main's CI had already run those against it. The tests where the two can
+// meet — whose imports reach both the synced module and this branch's own change — run through that
+// change in its place (`own_of`), which `vitest related` walks by its own graph. `shared` names them as
+// this graph reads them, but is never handed to vitest: the graph follows type-only imports and
+// ambient declarations too, and so reaches hundreds of tests the branch's change never runs
+// (joshuafolkken/kit#5066). Its being empty says the two never meet.
+//
+// **The import graph is TypeScript's, which drops an import it cannot resolve**, so only what it can
+// follow is left out. Nothing is left out where no graph can be built, the branch change or the map
+// cannot be read, the branch changed a file every test depends on, or the work tree holds a
+// component TypeScript does not resolve; a synced module that is gone or is such a component stays a
+// moved file. Each of those runs the tests importing it, as before. A synced module every test depends
+// on is not split either: `test-related.ts` leaves it to main's CI unless this branch changed it too.
+
+// `left` are the synced modules no longer handed to vitest, `shared` the tests where they meet the change,
+// `meeting` every file whose imports reach both — `shared` and the code between, which `josh ship`'s
+// lint settle reads (joshuafolkken/kit#4985) — all repository-root-relative.
+interface SyncedSplit {
+	left: ReadonlyArray<string>
+	shared: ReadonlyArray<string>
+	meeting: ReadonlyArray<string>
+}
+
+// What the split is read from: the synced modules this branch did not change, the code of its own
+// change, and every code file of the work tree, all absolute as the graph resolves them.
+interface SplitInputs {
+	root: string
+	main_only: ReadonlyArray<string>
+	own: ReadonlyArray<string>
+	universe: ReadonlyArray<string>
+}
+
+const NOTHING_LEFT: SyncedSplit = { left: [], shared: [], meeting: [] }
+const UNRESOLVED_EXTENSION = '.svelte'
+
+function is_unresolved(file: string): boolean {
+	return path.extname(file) === UNRESOLVED_EXTENSION
+}
+
+function is_beyond_graph(file: string): boolean {
+	return whole_suite_files.WHOLE_SUITE_FILES.has(path.normalize(file)) || is_unresolved(file)
+}
+
+function is_vouched(root: string, file: string): boolean {
+	if (!related_scope.is_relatable(file) || is_beyond_graph(file)) return false
+
+	return existsSync(path.join(root, file))
+}
+
+// The branch's own change as the graph reads it: its code files and the recorded readers of its
+// non-code ones. `undefined` where the graph cannot vouch for it.
+function own_of(
+	branch: ReadonlyArray<string> | undefined,
+	map: ReadMap | undefined,
+): ReadonlyArray<string> | undefined {
+	if (branch === undefined || map === undefined) return undefined
+
+	const data = branch.filter((file) => !related_scope.is_relatable(file))
+	const readers = data.flatMap((file) => test_read_map.readers_of(map, file))
+	const code = branch.filter((file) => related_scope.is_relatable(file))
+
+	return branch.some((file) => is_beyond_graph(file)) ? undefined : [...code, ...readers]
+}
+
+function split_with(graph: ImportGraph, inputs: SplitInputs): SyncedSplit {
+	const { root, main_only, own, universe } = inputs
+	const from_branch = graph.runtime_importers(own, universe)
+	const meeting = [...graph.runtime_importers(main_only, universe)]
+		.filter((file) => from_branch.has(file))
+		.map((file) => path.relative(root, file))
+	const shared = meeting.filter((file) => test_declared_logic.is_test_file(file))
+
+	return { left: main_only.map((file) => path.relative(root, file)), shared, meeting }
+}
+
+function absolute_in(root: string, files: ReadonlyArray<string>): Array<string> {
+	return files.map((file) => path.join(root, file))
+}
+
+async function split_by_graph(
+	root: string,
+	main_only: ReadonlyArray<string>,
+	own: ReadonlyArray<string>,
+): Promise<SyncedSplit> {
+	const graph = await import_graph.create(root)
+
+	if (graph === undefined) return NOTHING_LEFT
+
+	const universe = await test_pinned_reach.code_universe()
+
+	if (universe.some((file) => is_unresolved(file))) return NOTHING_LEFT
+
+	return split_with(graph, {
+		root,
+		main_only: absolute_in(root, main_only),
+		own: absolute_in(root, own),
+		universe,
+	})
+}
+
+// The graph is built only when a synced module this branch did not change is there to split. A failure
+// to build or walk it — git unreadable, a file gone mid-walk — leaves nothing out.
+async function split(
+	root: string,
+	synced: ReadonlyArray<string>,
+	branch: ReadonlyArray<string> | undefined,
+	map: ReadMap | undefined,
+): Promise<SyncedSplit> {
+	const own = own_of(branch, map)
+	const main_only = synced.filter((file) => !own?.includes(file) && is_vouched(root, file))
+
+	if (own === undefined || main_only.length === 0) return NOTHING_LEFT
+
+	try {
+		return await split_by_graph(root, main_only, own)
+	} catch {
+		return NOTHING_LEFT
+	}
+}
+
+const test_related_synced = { own_of, split, split_with }
+
+export type { SyncedSplit }
+export { test_related_synced }