@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/scripts/test/test-red-logic.ts

@@ -1,3 +1,4 @@
+import node_path from 'node:path'
 import { issue_bug_label } from '#scripts/issue/issue-bug-label'
 import { json_value } from '#scripts/lib/json-value'
 import { observation_ledger } from '#scripts/observations/observation-ledger'
@@ -11,7 +12,15 @@ import { test_declared_logic } from './test-declared-logic'
 // that test catches anything — the added and changed tests run against the merge-base, and at least one
 // of them has to fail there.
 
-type RedVerdict = 'red' | 'green' | 'no-test' | 'test-only'
+type RedVerdict = 'red' | 'green' | 'no-test' | 'stopped' | 'test-only'
+
+// One run's verdict and the test files that failed in it. `ran` is the number of test files the run
+// ran, absent on a verdict read back from a cache (joshuafolkken/kit#5078).
+interface RedProbe {
+	verdict: RedVerdict
+	failed: ReadonlyArray<string>
+	ran?: number
+}
 
 // The declaration a bug-fix Issue carries under its background heading, in the same slot as the
 // behavior-change declaration (`behavior-change-lint.ts`). Read from the declaration, never inferred,
@@ -55,23 +64,53 @@ function ran_file_count(report: string): number {
 	return json_value.parse_with(report, REPORT_SCHEMA)?.testResults.length ?? 0
 }
 
-// `no-test` when nothing ran; otherwise a failing run is `red` — the test caught the pre-fix tree — and
-// a passing one is `green`.
+// The test files a run failed in, as `josh test:pinned` stores them beside a `red` verdict
+// (joshuafolkken/kit#4790). Vitest names each by its absolute path, under the tree's own path or its real
+// one — a macOS temporary directory sits behind `/var` → `/private/var` — so each is read relative to the
+// first of `roots` it sits under. An unreadable report fails none.
+const RESULT_SCHEMA = z.object({ name: z.string(), status: z.string() })
+const RESULTS_SCHEMA = z.object({ testResults: z.array(RESULT_SCHEMA) })
+const FAILED_STATUS = 'failed'
+const PARENT_PREFIX = '..'
+
+function is_inside(name: string): boolean {
+	return !name.startsWith(PARENT_PREFIX) && !node_path.isAbsolute(name)
+}
+
+function relative_in(roots: ReadonlyArray<string>, file: string): Array<string> {
+	const relatives = roots.map((root) => node_path.relative(root, file))
+
+	return relatives.filter((name) => is_inside(name)).slice(0, 1)
+}
+
+function failed_files(report: string, roots: ReadonlyArray<string>): Array<string> {
+	const results = json_value.parse_with(report, RESULTS_SCHEMA)?.testResults ?? []
+
+	return results
+		.filter((result) => result.status === FAILED_STATUS)
+		.flatMap((result) => relative_in(roots, result.name))
+}
+
+// `no-test` when nothing ran and vitest passed with no tests; `stopped` when nothing ran and it failed
+// anyway — its config could not load, so no test was ever asked (joshuafolkken/kit#5043). Otherwise a
+// failing run is `red` — the test caught the pre-fix tree — and a passing one is `green`.
 function verdict_for(test_count: number, is_failed: boolean): RedVerdict {
-	if (test_count === 0) return 'no-test'
+	if (test_count === 0) return is_failed ? 'stopped' : 'no-test'
 
 	return is_failed ? 'red' : 'green'
 }
 
 // Only `green` on a declared bug fix is refused. `no-test` is already `josh test:declared`'s refusal
-// when a runtime file changed, a declared fix that touched only docs has nothing to reproduce, and a
-// `test-only` fix runs the same code on the merge-base as on HEAD.
+// when a runtime file changed, a declared fix that touched only docs has nothing to reproduce, a
+// `stopped` run asked no test, so it is neither red evidence nor green, and a `test-only` fix runs the
+// same code on the merge-base as on HEAD.
 function is_refused(body: string, verdict: RedVerdict): boolean {
 	return verdict === 'green' && is_bug_fix(body)
 }
 
 const test_red_logic = {
 	BUG_DECLARATION_LINE,
+	failed_files,
 	is_bug_fix,
 	is_refused,
 	is_test_only,
@@ -80,5 +119,5 @@ const test_red_logic = {
 	verdict_for,
 }
 
-export type { RedVerdict }
+export type { RedProbe, RedVerdict }
 export { test_red_logic }

package/scripts/test/test-red.ts

@@ -1,15 +1,16 @@
 import { existsSync } from 'node:fs'
-import { readFile, rm } from 'node:fs/promises'
+import { readFile, realpath, rm } from 'node:fs/promises'
 import path from 'node:path'
 import { base_tree, type BaseTree } from '#scripts/git/base-tree'
 import { change_base } from '#scripts/git/change-base'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { git_location_environment } from '#scripts/git/git-location-environment'
 import { execa } from 'execa'
-import { test_red_logic, type RedVerdict } from './test-red-logic'
+import { test_red_logic, type RedProbe, type RedVerdict } from './test-red-logic'
+import { vitest_cache_directory } from './vitest-cache-directory'
 
 // `josh test:red` — run the added and changed Vitest files against the pre-fix tree and print `red`,
-// `green`, `no-test` or `test-only`.
+// `green`, `no-test`, `stopped` or `test-only`.
 //
 // **The pre-fix tree is a detached worktree at the merge-base, never the caller's checkout**
 // (`base-tree.ts`). The tests are copied in from the working tree, so what runs is the new test
@@ -17,9 +18,12 @@ import { test_red_logic, type RedVerdict } from './test-red-logic'
 
 const TREE_PREFIX = 'josh-test-red-'
 const REPORT_NAME = 'report.json'
+// Beside the tree, so the run's dependency optimizer never rewrites the borrowed `node_modules/.vite`
+// a gate beside it imports from (`vitest-cache-directory.ts`).
+const CACHE_NAME = 'vite-cache'
 const VITEST_BIN = path.join(base_tree.NODE_MODULES, '.bin', 'vitest')
 const USAGE =
-	'Usage: josh test:red — prints red / green / no-test / test-only for the changed tests on the merge-base'
+	'Usage: josh test:red — prints red / green / no-test / stopped / test-only for the changed tests on the merge-base'
 
 interface RedRun {
 	verdict: RedVerdict
@@ -45,32 +49,43 @@ async function read_report(report: string): Promise<string> {
 // `josh test:pinned`. `--passWithNoTests` keeps "the filter matched nothing" from reading as a
 // failure, and the JSON report — written beside the tree, never into it — says whether anything ran at
 // all, so a file the old config excludes is `no-test` rather than a `green` that refuses a correct fix.
-// A test that ran and broke, or a file that could not load against the old code, makes it `red`. The
-// report is removed first, so a run that writes none never reads the one before it.
-async function verdict_in(
+// A test that ran and broke, or a file that could not load against the old code, makes it `red`, and
+// the files it broke in come back beside the verdict. The report is removed first, so a run that writes
+// none never reads the one before it.
+async function probe_in(
 	{ parent, tree }: BaseTree,
 	selection: ReadonlyArray<string>,
-): Promise<RedVerdict> {
+): Promise<RedProbe> {
 	const report = path.join(parent, REPORT_NAME)
 	const vitest_args = [...selection, '--passWithNoTests', ...reporter_arguments(report)]
 
 	await rm(report, { force: true })
 	const result = await execa(path.join(tree, VITEST_BIN), vitest_args, {
 		cwd: tree,
-		env: git_location_environment.location_free_environment(),
+		env: {
+			...git_location_environment.location_free_environment(),
+			[vitest_cache_directory.CACHE_DIRECTORY_KEY]: path.join(parent, CACHE_NAME),
+		},
 		extendEnv: true,
 		reject: false,
 	})
-	const ran = test_red_logic.ran_file_count(await read_report(report))
+	const text = await read_report(report)
+	const ran = test_red_logic.ran_file_count(text)
 
-	return test_red_logic.verdict_for(ran, result.exitCode !== 0)
+	return {
+		verdict: test_red_logic.verdict_for(ran, result.exitCode !== 0),
+		failed: test_red_logic.failed_files(text, [tree, await realpath(tree)]),
+		ran,
+	}
 }
 
 async function verdict_on(base: string, files: ReadonlyArray<string>): Promise<RedVerdict> {
 	return await base_tree.with_tree(TREE_PREFIX, base, async (pre_fix) => {
 		await base_tree.copy_in(pre_fix.tree, files)
 
-		return await verdict_in(pre_fix, ['run', ...files])
+		const probe = await probe_in(pre_fix, ['run', ...files])
+
+		return probe.verdict
 	})
 }
 
@@ -78,7 +93,7 @@ async function verdict_on(base: string, files: ReadonlyArray<string>): Promise<R
 // `no-test` — there is no pre-fix tree to run against, and a guard fails open. A change whose every path
 // is a test file is `test-only` without a run: the merge-base runs the same code as HEAD.
 async function run(): Promise<RedRun> {
-	const base = await change_base.resolved()
+	const base = await change_base.resolved_through_merge()
 	const paths = await changed_paths.read_changed_paths(false)
 	const files = changed_tests(paths)
 
@@ -103,7 +118,12 @@ async function main(argv: ReadonlyArray<string>): Promise<number> {
 	return 0
 }
 
-const test_red = { main, run, verdict_in }
+// Whether the checkout has the Vitest `probe_in` runs; without it every run would read `no-test`.
+function has_runner(): boolean {
+	return existsSync(VITEST_BIN)
+}
+
+const test_red = { has_runner, main, probe_in, run }
 
 export type { RedRun }
 export { test_red }

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

@@ -0,0 +1,37 @@
+import { core_budget } from '#scripts/gate/core-budget'
+import { gate_plan } from '#scripts/gate/gate-plan'
+import { test_pinned_reach } from './test-pinned-reach'
+import { related_scope } from './test-related-scope'
+
+// The cores a `josh test:related` vitest pass claims once its files are known (joshuafolkken/kit#5135):
+// a narrowed pass by the test files its imports reach — not by its own files, one of which may reach
+// hundreds — and the whole suite (`undefined`), or files no graph can be built for, by the full width
+// a direct unit run holds.
+async function claim_weight(files: ReadonlyArray<string> | undefined): Promise<number> {
+	const tests = files === undefined ? undefined : await test_pinned_reach.reached_test_count(files)
+
+	return tests === undefined ? gate_plan.direct_unit_weight() : gate_plan.scoped_unit_weight(tests)
+}
+
+// **Each vitest pass takes its claim here, not on the command entry**: the entry is reserved before
+// the scope resolves, so it could only ever claim the whole width. `vitest_share` reads this claim
+// back as the `--maxWorkers` bound. Under `josh gate` the gate's claim covers the run, so none is
+// sized.
+async function with_unit_claim(
+	files: ReadonlyArray<string> | undefined,
+	run: () => Promise<number>,
+): Promise<number> {
+	if (core_budget.is_covered()) return await run()
+
+	const weight = await claim_weight(files)
+
+	return await core_budget.with_command_reservation(weight, run, {
+		memory_mb: gate_plan.unit_memory(weight),
+		command: related_scope.COMMAND_NAME,
+		is_unit: true,
+	})
+}
+
+const test_related_claim = { with_unit_claim }
+
+export { test_related_claim }

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

@@ -2,17 +2,20 @@
 import { fileURLToPath } from 'node:url'
 import { changed_file_scope } from '#scripts/git/changed-file-scope'
 import { run_ship_removed_rows } from '#scripts/run/ship/run-ship-removed-rows'
+import { split_early_notice } from '#scripts/split/split-early-notice'
 import { test_related } from './test-related'
 
 // The `josh test:related` entry, kept apart from `test-related.ts` because `check-inputs.ts` imports
 // that one: a bundle is one file, so a main guard there would fire for every command that carries it
 // (joshuafolkken/kit#4186). A green run then shows the tests the change removed, the one place a run
-// meets them before `josh ship` (joshuafolkken/kit#4563).
+// meets them before `josh ship` (joshuafolkken/kit#4563), and any run shows the split notice once per
+// Issue when the diff has outgrown the guide (joshuafolkken/kit#4642).
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
 	const exit_code = await test_related.run_related_tests(
 		process.argv.slice(changed_file_scope.ARGV_START),
 	)
 
 	if (exit_code === 0) await run_ship_removed_rows.surface()
+	await split_early_notice.surface()
 	process.exitCode = exit_code
 }

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

@@ -0,0 +1,91 @@
+import type { MovedParts } from '#scripts/gate/moved-paths'
+import { test_declared_logic } from './test-declared-logic'
+import type { ReadMap } from './test-read-map'
+import { related_scope, type ScopeRequest } from './test-related-scope'
+import { test_related_synced, type SyncedSplit } from './test-related-synced'
+import { whole_suite_files } from './whole-suite-files'
+
+// How `josh test:related` reads what moved since its last green run (`since-green.ts`) into the change
+// it narrows by — split out of `test-related.ts`, which runs the reading.
+
+// The change a narrowing reads, and the map it reads it against. `is_unmoved` is the since-green
+// reading's positive fact that nothing moved since this command was last green on this checkout.
+// `synced` is the part of the change a main sync brought in, kept for the run's ledger record, and
+// `since_map` the part the change since the map's tree joined to what this change moved. `branch` is
+// this branch's own change from its merge base, where it was read.
+type ChangeReading = Pick<ScopeRequest, 'changed' | 'map' | 'since_map'> & {
+	is_unmoved?: true
+	synced?: ReadonlyArray<string>
+	branch?: ReadonlyArray<string> | undefined
+}
+
+function is_whole_suite(file: string): boolean {
+	return whole_suite_files.WHOLE_SUITE_FILES.has(file)
+}
+
+// **A non-code file a main sync brought in is not this branch's change** (joshuafolkken/kit#4572), so it
+// joins `since_map`: it neither adds the tests reading it nor sends the run to the whole suite — main's
+// CI verified it. So does a synced file every test depends on, which the split cannot narrow
+// (joshuafolkken/kit#4993): main's CI ran the whole suite on it, and this branch's own tests run on it
+// anyway. Any other synced module is `test-related-synced.ts`'s: only this branch's change runs for it,
+// where the two meet. A branch change git cannot read marks nothing.
+function synced_data(
+	synced: ReadonlyArray<string>,
+	branch: ReadonlyArray<string> | undefined,
+): ReadonlyArray<string> {
+	const data = synced.filter((file) => !related_scope.is_relatable(file) || is_whole_suite(file))
+
+	return data.filter((file) => !(branch ?? data).includes(file))
+}
+
+// **The branch's own test files stay out of `since_map`** (joshuafolkken/kit#4393), so each runs again
+// on every bare run after a green one — the map holds no entry for a read one started since its tree.
+// Only main's and another lane's test files are left to CI (joshuafolkken/kit#4896). A branch change git
+// cannot read keeps every test file.
+function without_own_tests(
+	since_map: ReadonlyArray<string>,
+	branch: ReadonlyArray<string> | undefined,
+): ReadonlyArray<string> {
+	return since_map.filter(
+		(file) => !test_declared_logic.is_test_file(file) || branch?.includes(file) === false,
+	)
+}
+
+// The moved files handed on as explicit arguments, the synced modules the split left out taken away.
+// Where one meets this branch's change, the change runs in its place (`test-related-synced.ts`) — named
+// even when only the sync moved, since a green branch side would otherwise run nothing.
+function narrowed_moved(
+	moved: ReadonlyArray<string>,
+	split: SyncedSplit,
+	branch: ReadonlyArray<string> | undefined,
+	map: ReadMap | undefined,
+): ReadonlyArray<string> {
+	const kept = moved.filter((file) => !split.left.includes(file))
+	const own = split.shared.length === 0 ? [] : test_related_synced.own_of(branch, map)
+
+	return [...new Set([...kept, ...(own ?? [])])]
+}
+
+// The reading's `since_map`: what this branch did not change. The synced modules left out join it and
+// the change, so they settle as reaching no test rather than leaving an empty selection that runs the
+// whole suite.
+function moved_reading(
+	change: ChangeReading,
+	parts: MovedParts,
+	branch: ReadonlyArray<string> | undefined,
+	split: SyncedSplit,
+): ChangeReading {
+	const since_map = [
+		...without_own_tests(change.since_map ?? [], branch),
+		...synced_data(parts.synced, branch),
+		...split.left,
+	]
+	const changed = [...new Set([...(change.changed ?? []), ...split.left])]
+
+	return { ...change, changed, since_map: [...new Set(since_map)], synced: parts.synced, branch }
+}
+
+const test_related_moved = { is_whole_suite, moved_reading, narrowed_moved }
+
+export type { ChangeReading }
+export { test_related_moved }

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

@@ -1,7 +1,8 @@
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
-import { lane_ledger, type TestRelatedRecord } from '#scripts/lane/lane-ledger'
+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'
 
@@ -21,9 +22,13 @@ interface RunInput {
 	// 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 — never the run's own change. It holds
-	// the synced non-code files as well, which the record counts as `synced` alone.
+	// 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 {
@@ -69,15 +74,11 @@ async function with_test_count(
 	}
 }
 
-// The scope's files the change did not name — the map's readers and the code readers it added.
-function readers_of(input: RunInput, changed: ReadonlySet<string>): number {
+// 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) => !changed.has(path.relative(input.root, file))).length
-}
-
-function part_of(part: ReadonlyArray<string>, changed: ReadonlySet<string>): number {
-	return part.filter((file) => changed.has(file)).length
+	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.
@@ -87,20 +88,39 @@ function triggers_of(input: RunInput): Partial<TestRelatedRecord> {
 	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 changed = new Set(input.changed)
-	const synced = part_of(input.synced, changed)
-	// A synced non-code file is in `since_map` too (`synced_data` in `test-related.ts`), counted once.
-	const since_map = part_of(
-		input.since_map.filter((file) => !input.synced.includes(file)),
-		changed,
-	)
+	const { own, synced, since_map } = parts_of(input)
 	const record = {
-		scope: related_scope.scope_kind(input.scope),
-		changed: changed.size - synced - since_map,
-		synced,
-		since_map,
-		readers: readers_of(input, changed),
+		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),
 	}
@@ -110,7 +130,7 @@ function record_of(input: RunInput, result: RunResult): TestRelatedRecord {
 
 // Best-effort, as every ledger write is.
 async function record_run(input: RunInput, result: RunResult, ledger?: string): Promise<void> {
-	await lane_ledger.record_test_related(record_of(input, result), ledger)
+	await lane_ledger_write.record_test_related(record_of(input, result), ledger)
 }
 
 const test_related_record = { record_of, record_run, with_test_count }