@joshuafolkken/kit 1.1784.0 → 1.2116.0

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

@@ -1,6 +1,7 @@
 import path from 'node:path'
+import { since_green } from '#scripts/gate/since-green'
 import { changed_file_scope, type ChangedFileScope } from '#scripts/git/changed-file-scope'
-import { test_declared_logic } from './test-declared-logic'
+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'
 
@@ -14,10 +15,10 @@ import { whole_suite_files } from './whole-suite-files'
 // 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 the tree did not hold it, or a file every test
+// 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 the tree held and no test read
-// inside (joshuafolkken/kit#4303), so a change made only of those runs nothing. CI runs the whole suite
+// (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.
 //
@@ -53,7 +54,7 @@ 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 or read'
 const NO_MAP_REASON = 'no test-read map covers the changed non-code file'
-const UNMOVED_REASON = 'nothing moved since its last green run on this checkout'
+const { UNMOVED_REASON } = since_green
 const WHOLE_SUITE_SUFFIX = 'affects every test'
 const UNRECORDED_SUFFIX = 'is read by no recorded test'
 
@@ -97,13 +98,20 @@ interface ScopeRequest {
 	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. A non-code file of it still adds the
-	// tests reading it, a source file only through `naming_moved`, but neither ever sends the run to
-	// the whole suite: this tree verified it already, or main's CI did (joshuafolkken/kit#4527).
+	// 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 source files of `since_map` that name a file this change moved — with its test files, the
-	// only ones of that part handed to vitest (joshuafolkken/kit#4532). See `is_code_input`.
+	// 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
@@ -125,18 +133,17 @@ function is_moved(request: ScopeRequest, file: string): boolean {
 	return request.since_map?.includes(file) !== true
 }
 
-// **A source file only the map's tree differs by — another lane's change, or main's since — is handed
-// to vitest only when it names a file this change moved** (joshuafolkken/kit#4532). 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 of that part always joins: the map holds no entry for it, it may reach a moved file through a
-// helper's read rather than its own, and it runs only itself. 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.
+// **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) || test_declared_logic.is_test_file(file)) return true
+	if (is_moved(request, file)) return true
 
 	return request.naming_moved?.has(file) === true
 }
@@ -147,9 +154,9 @@ function all_scope(reason: string, triggers: ReadonlyArray<string> = [], root =
 	return { mode: 'all', files: triggers.map((file) => path.join(root, file)), reason }
 }
 
-// A file no recorded test read narrows only when the recorded tree held it, or held its directory and
-// no recorded test read inside that: any other file added since is one the recorder never saw, so its
-// having no reader says nothing.
+// 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
 
@@ -183,7 +190,7 @@ function code_readers(code: ReadonlyArray<string>, map: ReadMap | undefined): Ar
 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) no test reads` }
+	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
@@ -202,28 +209,86 @@ function narrowed_scope(selection: Selection, request: ScopeRequest): RelatedSco
 	return { mode: 'related', files: present, reason: `${String(present.length)} related file(s)` }
 }
 
-// `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 {
-	const { changed, root } = request
+// 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) ?? [])
 
-	if (changed === undefined) return all_scope(UNREADABLE_REASON)
+	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.filter(
+		(file) => WHOLE_SUITE_FILES.has(file) && !is_narrowed(request, file) && is_moved(request, file),
+	)
+}
 
-	const whole = changed.filter((file) => WHOLE_SUITE_FILES.has(file) && is_moved(request, file))
+function resolve_read(
+	request: ScopeRequest & { changed: ReadonlyArray<string> },
+	entry_tests: ReadonlyArray<string>,
+): RelatedScope {
+	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 code = changed.filter((file) => is_code_input(request, file))
+	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)),
+		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]
+	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 narrowed_scope({ files, unread: resolution.unread }, request)
+	return resolve_read({ ...request, changed: pure.unread }, pure.files)
 }
 
 function describe_scope(scope: RelatedScope, root: string): string {

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 }

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

@@ -0,0 +1,84 @@
+import { readdirSync } from 'node:fs'
+import path from 'node:path'
+import { related_scope, type RelatedScope } from './test-related-scope'
+
+// `josh test:related --touched` — the implementation loop's re-check (joshuafolkken/kit#5237). A change
+// near a hub reaches hundreds of test files, and paying that reach after every small edit repeats it
+// minutes apart. **The touched scope reads no test-read map and no import graph**: it is the diff's own
+// test files and, for each changed module `foo.ts`, its colocated `foo.test.ts` and `foo.*.test.ts`.
+// What an edit breaks further away is the full-reach run's to find, so a touched run leaves no green
+// record (`scoped-green.ts`) and is recorded in the lane ledger under its own kind.
+
+const TOUCHED_FLAG = '--touched'
+const TOUCHED_KIND = 'touched'
+const TEST_SUFFIX = '.test.ts'
+const TOUCHED_REASON = 'the diff test files and the tests named after its modules'
+const NOTHING_TOUCHED_REASON = 'no test file is in the diff or named after a changed module'
+
+type ListDirectory = (directory: string) => ReadonlyArray<string>
+
+// A directory that cannot be listed holds no test to run.
+function list_directory(directory: string): ReadonlyArray<string> {
+	try {
+		return readdirSync(directory)
+	} catch {
+		return []
+	}
+}
+
+function is_named_after(module_file: string, name: string): boolean {
+	const stem = path.basename(module_file, path.extname(module_file))
+
+	return name.startsWith(`${stem}.`) && name.endsWith(TEST_SUFFIX)
+}
+
+// A test file of the diff runs itself while it is still on disk; a module runs its same-named tests.
+function tests_of(root: string, file: string, list: ListDirectory): Array<string> {
+	const directory = path.dirname(file)
+	const names = list(path.join(root, directory))
+
+	if (file.endsWith(TEST_SUFFIX)) return names.includes(path.basename(file)) ? [file] : []
+	if (!related_scope.is_relatable(file)) return []
+
+	return names
+		.filter((name) => is_named_after(file, name))
+		.map((name) => path.join(directory, name))
+}
+
+function touched_tests(
+	root: string,
+	changed: ReadonlyArray<string>,
+	list: ListDirectory = list_directory,
+): Array<string> {
+	return [...new Set(changed.flatMap((file) => tests_of(root, file, list)))]
+}
+
+// `changed` is repository-root-relative; `undefined` — a diff git could not read — runs the whole suite,
+// as an unreadable change does for the full-reach run.
+function touched_scope(
+	root: string,
+	changed: ReadonlyArray<string> | undefined,
+	list: ListDirectory = list_directory,
+): RelatedScope {
+	const { UNREADABLE_REASON } = related_scope
+
+	if (changed === undefined) return { mode: 'all', files: [], reason: UNREADABLE_REASON }
+
+	const files = touched_tests(root, changed, list).map((file) => path.join(root, file))
+
+	if (files.length === 0) return { mode: 'none', files: [], reason: NOTHING_TOUCHED_REASON }
+
+	return { mode: 'related', files, reason: TOUCHED_REASON }
+}
+
+const test_related_touched = {
+	NOTHING_TOUCHED_REASON,
+	TOUCHED_FLAG,
+	TOUCHED_KIND,
+	TOUCHED_REASON,
+	touched_scope,
+	touched_tests,
+}
+
+export type { ListDirectory }
+export { test_related_touched }