@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/scripts/run/ship/run-ship-stop-cause.ts

@@ -8,6 +8,7 @@ import { is_blocked_cause } from '#scripts/gh/git-pr-checks-missing'
 import { NO_CHECKS_MESSAGE } from '#scripts/gh/git-pr-checks-watch'
 import { git_error } from '#scripts/git/git-error'
 import type { StopRecord } from '#scripts/lane/lane-ledger-schema'
+import type { UnpinnedStop } from '#scripts/lane/lane-ledger-schema-ship'
 import { run_ship_review, type StopFinding } from './run-ship-review'
 import { run_ship_stage, type Stage } from './run-ship-stage'
 
@@ -89,6 +90,8 @@ interface StoppedOutput {
 	out?: string
 	conflicts?: ReadonlyArray<string>
 	preconditions?: ReadonlyArray<string>
+	// The path an `unpinned` precondition's stop took (joshuafolkken/kit#7552).
+	unpinned?: UnpinnedStop
 	cause?: Cause
 }
 
@@ -191,12 +194,20 @@ function details_of(stage: Stage, failed: StoppedOutput = NO_OUTPUT): ReadonlyAr
 	return run_ship_review.blocking_details(failed.body)
 }
 
+// A preflight stop's unmet preconditions and the path its `unpinned` one took (joshuafolkken/kit#7552).
+function preflight_of({ preconditions, unpinned }: StoppedOutput): Partial<StopRecord> {
+	return {
+		...(preconditions !== undefined && { preconditions: [...preconditions] }),
+		...(unpinned !== undefined && { unpinned }),
+	}
+}
+
 // The lane ledger's record of one stop — the stage, its cause and, for a preflight, which
 // preconditions were unmet, so `lane:stats` counts the one worth meeting before a ship
 // (joshuafolkken/kit#4166); for a review, which kinds of finding stopped it (joshuafolkken/kit#4426);
 // for a followup red on a check, which checks failed (joshuafolkken/kit#7333).
 function record_of(issue: number, stage: Stage, failed: StoppedOutput = NO_OUTPUT): StopRecord {
-	const { body, conflicts, preconditions } = failed
+	const { body, conflicts } = failed
 	const cause = cause_of(stage, failed)
 	const findings = findings_of(stage, cause, body)
 	const checks = checks_of(stage, cause, body)
@@ -205,7 +216,7 @@ function record_of(issue: number, stage: Stage, failed: StoppedOutput = NO_OUTPU
 		issue,
 		reason: run_ship_stage.stop_reason(stage, conflicts),
 		cause,
-		...(preconditions !== undefined && { preconditions: [...preconditions] }),
+		...preflight_of(failed),
 		...(findings.length > 0 && { findings: [...findings] }),
 		...(checks.length > 0 && { checks: [...checks] }),
 	}

package/scripts/run/ship/run-ship.ts

@@ -9,6 +9,7 @@
 // `run:tail`, ship stops at the first failed step: a red gate must never reach the commit, so the
 // composite ends at the failure, and the report names the step that failed so the run reads only it.
 
+import type { UnpinnedStop } from '#scripts/lane/lane-ledger-schema-ship'
 import { run_section, type Section } from '#scripts/run/run-section'
 import { run_tail } from '#scripts/run/run-tail'
 import type { PreDetachResult } from './run-ship-pre-detach'
@@ -36,6 +37,8 @@ type ShipSection = Section & {
 	conflicts?: ReadonlyArray<string>
 	// The kinds of the preconditions a stopped preflight found unmet, recorded with the stop.
 	preconditions?: ReadonlyArray<string>
+	// The path an `unpinned` precondition's stop took, recorded with the stop (joshuafolkken/kit#7552).
+	unpinned?: UnpinnedStop
 	// The cause a stopped review round tagged its stop with, recorded with the stop.
 	cause?: Cause
 	// The stage found nothing to do, and why it ran or was skipped — both read onto its event line.
@@ -89,13 +92,16 @@ function format_report(sections: ReadonlyArray<ShipSection>): string {
 	return `${body}${run_section.SECTION_SEPARATOR}${STOPPED_PREFIX}${failed.header}`
 }
 
-// Preserve the preflight refusal and add any failed pre-detach check kinds to its stop record.
+// Preserve the preflight refusal and add any failed pre-detach check kinds, and the path an `unpinned`
+// one took, to its stop record.
 function with_checks(stop: ShipSection, checks: PreDetachResult): ShipSection {
 	if (checks.code === run_section.SUCCESS_EXIT_CODE) return stop
+	const { unpinned } = checks
 
 	return {
 		...stop,
 		preconditions: [...(stop.preconditions ?? []), ...(checks.preconditions ?? [])],
+		...(unpinned !== undefined && { unpinned }),
 	}
 }
 

package/scripts/split/split-assess.ts

@@ -6,6 +6,7 @@ import { lane_implement_rate, type ImplementRate } from '#scripts/lane/lane-impl
 import type { SizeRatios } from '#scripts/lane/lane-size-stats'
 import { test_declared_logic } from '#scripts/test/test-declared-logic'
 import { declared_growth } from './declared-growth'
+import { split_cap } from './split-cap'
 
 // The size half of the split assessment, measured rather than estimated.
 //
@@ -46,23 +47,8 @@ interface SplitGuide extends DeclaredSize {
 	growth?: SizeRatios
 }
 
-// The guide's single source: `split-assessment.md` states these once and a test pins the two equal.
-// Strictly greater than: "more than" puts the bar above the number, not at it. Lowered from 10 / 400
-// once a lane estimated at 6 files / 250 lines merged at about 23 files / 390 lines (joshuafolkken/kit#5384).
-const FILE_GUIDE = 8
-const LINE_GUIDE = 200
-// The cap, one and a half times the guide: past it a declared reason no longer keeps an Issue as one. A
-// lane declared past it with a reason overran both its time budget and its declared files by far
-// (joshuafolkken/kit#5502). Lowered from 3 once the projected implement time became the main bar — the
-// cap is the backstop where no rate is measured (joshuafolkken/kit#6066).
-const CAP_FACTOR = 1.5
-const FILE_CAP = FILE_GUIDE * CAP_FACTOR
-const LINE_CAP = LINE_GUIDE * CAP_FACTOR
-const DEFAULT_GUIDE: SplitGuide = {
-	files: FILE_GUIDE,
-	lines: LINE_GUIDE,
-	cap: { files: FILE_CAP, lines: LINE_CAP },
-}
+const { CAP_FACTOR, DEFAULT_CAP, FILE_CAP, FILE_GUIDE, LINE_CAP, LINE_GUIDE } = split_cap
+const DEFAULT_GUIDE: SplitGuide = { files: FILE_GUIDE, lines: LINE_GUIDE, cap: DEFAULT_CAP }
 
 // Keep fractional thresholds: rounding would change the budget's strict comparison boundary.
 function guide_for(minutes: number, measured?: ImplementRate, growth?: SizeRatios): SplitGuide {
@@ -190,9 +176,8 @@ function verdict_for(
 	return files > guide.files || lines > guide.lines ? SPLIT_VERDICT : SINGLE_VERDICT
 }
 
-// Strictly greater than, as the guide is: the cap itself still runs as one Issue.
 function is_over_cap(files: number, lines: number, guide: SplitGuide = DEFAULT_GUIDE): boolean {
-	return files > guide.cap.files || lines > guide.cap.lines
+	return split_cap.is_over(files, lines, guide.cap)
 }
 
 // `added` lists the files the branch adds, so a new module and its importer count as one file.
@@ -292,11 +277,11 @@ const NOTICE_SECTION = 'Over the guide before the gate'
 const QUESTION_SECTION = 'The question'
 // The filing's reason line (`size_estimate`); it does not answer a later split notice.
 const REASON_PREFIX = issue_body_keys.prefix('no_split_reason')
-const NOTICE_ACTION = `go on to the end; a started Issue is never split, and the merge records the overrun as a pre-split miss — split-assessment.md → "${NOTICE_SECTION}"`
+const NOTICE_ACTION = `go on to the end; a started Issue is never split, and the merge records an overrun past the cap as a pre-split miss — split-assessment.md → "${NOTICE_SECTION}"`
 
 // The notice for a diff past `notice_bar` on either axis — strictly greater than, as the guide is — and
-// a diff at or under it gives none. A merge past it is recorded as a pre-split miss
-// (`lane-size-record.ts`, joshuafolkken/kit#7183); size alone never stops the run (joshuafolkken/kit#6602).
+// a diff at or under it gives none. A merge past the cap, not this bar, is recorded as a pre-split
+// miss (`lane-size-record.ts`, joshuafolkken/kit#7579); size alone never stops the run (joshuafolkken/kit#6602).
 function notice(
 	measurement: SizeMeasurement,
 	declared?: DeclaredSize,

package/scripts/split/split-cap.ts

@@ -0,0 +1,31 @@
+// The fallback split guide and its cap, with no imports so a `lane:stats` reader can apply the cap
+// without the cycle `split-assess` → `lane-implement-rate` → `lane-size-stats` (joshuafolkken/kit#7579).
+
+interface SplitCap {
+	files: number
+	lines: number
+}
+
+// The guide's single source: `split-assessment.md` states these once and a test pins the two equal.
+// Strictly greater than: "more than" puts the bar above the number, not at it. Lowered from 10 / 400
+// once a lane estimated at 6 files / 250 lines merged at about 23 files / 390 lines (joshuafolkken/kit#5384).
+const FILE_GUIDE = 8
+const LINE_GUIDE = 200
+// The cap, one and a half times the guide: past it a declared reason no longer keeps an Issue as one. A
+// lane declared past it with a reason overran both its time budget and its declared files by far
+// (joshuafolkken/kit#5502). Lowered from 3 once the projected implement time became the main bar — the
+// cap is the backstop where no rate is measured (joshuafolkken/kit#6066).
+const CAP_FACTOR = 1.5
+const FILE_CAP = FILE_GUIDE * CAP_FACTOR
+const LINE_CAP = LINE_GUIDE * CAP_FACTOR
+const DEFAULT_CAP: SplitCap = { files: FILE_CAP, lines: LINE_CAP }
+
+// Strictly greater than, as the guide is: the cap itself still runs as one Issue.
+function is_over(files: number, lines: number, cap: SplitCap = DEFAULT_CAP): boolean {
+	return files > cap.files || lines > cap.lines
+}
+
+const split_cap = { CAP_FACTOR, DEFAULT_CAP, FILE_CAP, FILE_GUIDE, LINE_CAP, LINE_GUIDE, is_over }
+
+export { split_cap }
+export type { SplitCap }

package/scripts/test/direct-importers.ts

@@ -15,6 +15,9 @@ const PACKAGE_FILE = 'package.json'
 const WILDCARD = '*'
 const CURRENT_DIRECTORY_PREFIX = './'
 const NUL = '\0'
+const SCOPE_PREFIX = '@'
+const SCOPED_SEGMENTS = 2
+const NON_PACKAGE_PATTERN = /(?:^[.#/])|:/u
 
 // The module specifiers a source names in a static or dynamic import, an export-from or a `vi.mock`.
 const SPECIFIER_PATTERN = /(?:\bfrom\s+|\bimport\s*\(\s*|\bimport\s+|\bmock\(\s*)["']([^"']+)["']/gu
@@ -115,11 +118,18 @@ function source_reader(root: string): SourceReader {
 	return { imports: read_imports(root), read_source: (file) => read_source_at(root, file) }
 }
 
-// The test files the work tree at `root` holds, tracked or not but not ignored, repository-relative.
-async function test_files(root: string): Promise<Array<string>> {
+// The files the work tree at `root` holds, tracked or not but not ignored, repository-relative.
+async function work_tree_files(root: string): Promise<Array<string>> {
 	const listed = await git_spawn.read(['-C', root, 'ls-files', '-coz', '--exclude-standard'])
 
-	return listed.split(NUL).filter((file) => test_declared_logic.is_test_file(file))
+	return listed.split(NUL).filter((file) => file !== '')
+}
+
+// The test files among them.
+async function test_files(root: string): Promise<Array<string>> {
+	const files = await work_tree_files(root)
+
+	return files.filter((file) => test_declared_logic.is_test_file(file))
 }
 
 // The test files of `tests` importing `file` directly; an unreadable one imports nothing.
@@ -169,8 +179,41 @@ async function every_test_importers(
 	return await importers_of(root, every_test_imports_of(files))
 }
 
+// The package a bare specifier names — `name` or `@scope/name`, its subpath dropped — or `undefined`
+// for a relative, `#` alias or `node:` specifier.
+function package_of(specifier: string): string | undefined {
+	if (NON_PACKAGE_PATTERN.test(specifier)) return undefined
+
+	const segments = specifier.split(path.posix.sep)
+
+	const kept = specifier.startsWith(SCOPE_PREFIX) ? SCOPED_SEGMENTS : 1
+
+	return segments.slice(0, kept).join(path.posix.sep)
+}
+
+function imports_package(source: string, packages: ReadonlySet<string>): boolean {
+	return specifiers_of(source).some((specifier) => packages.has(package_of(specifier) ?? ''))
+}
+
+// The files of the work tree at `root` that `is_source` admits and whose text imports one of
+// `packages` by its bare specifier (joshuafolkken/kit#7554) — what `vitest related` walks to the tests
+// a lockfile change reaches.
+async function package_importers(
+	root: string,
+	packages: ReadonlySet<string>,
+	is_source: (file: string) => boolean,
+): Promise<Array<string>> {
+	if (packages.size === 0) return []
+
+	const files = await work_tree_files(root)
+	const sources = files.filter((file) => is_source(file))
+
+	return sources.filter((file) => imports_package(read_source_at(root, file) ?? '', packages))
+}
+
 const direct_importers = {
 	every_test_importers,
+	package_importers,
 	every_test_imports_of,
 	importers_of,
 	is_every_test_import,

package/scripts/test/lockfile-changed-packages.ts

@@ -0,0 +1,155 @@
+import { isDeepStrictEqual } from 'node:util'
+import { loadAll } from 'js-yaml'
+import { z } from 'zod'
+import { whole_suite_files } from './whole-suite-files'
+
+// **`pnpm-lock.yaml` is a whole-suite file only for what moves every test** (joshuafolkken/kit#7554). A
+// change resolving other versions of some packages reaches the modules importing them — and, through
+// `vitest related`, their tests — rather than every test. The packages it moved are the entries of
+// `packages` / `snapshots` that differ, with every package depending on one of them, however far. The
+// whole suite still runs when either side cannot be read, when anything else moved — an importer's
+// specifier or dependency, an override, a setting — or when a unit runtime package moved
+// (`whole_suite_files.is_unit_runtime_package`).
+
+const LOCKFILE_PATH = 'pnpm-lock.yaml'
+const VERSION_KEY = 'version'
+const SCOPE_PREFIX = '@'
+const DEPENDENCY_GROUPS = ['dependencies', 'optionalDependencies'] as const
+const RESOLUTION_KEYS: ReadonlySet<string> = new Set(['importers', 'packages', 'snapshots'])
+
+const entries_schema = z.record(z.string(), z.unknown()).default({})
+const document_schema = z.looseObject({
+	importers: entries_schema,
+	packages: entries_schema,
+	snapshots: entries_schema,
+})
+const snapshot_schema = z.looseObject({
+	dependencies: entries_schema,
+	optionalDependencies: entries_schema,
+})
+
+type LockfileDocument = z.infer<typeof document_schema>
+type Entries = Readonly<Record<string, unknown>>
+
+function documents_of(text: string): Array<LockfileDocument> | undefined {
+	try {
+		return loadAll(text).map((document) => document_schema.parse(document))
+	} catch {
+		return undefined
+	}
+}
+
+// A snapshot key carries the peer suffix (`name@1.0.0(peer@2.0.0)`); its package key does not.
+function to_package_key(snapshot_key: string): string {
+	const peer_start = snapshot_key.indexOf('(', 1)
+
+	return peer_start === -1 ? snapshot_key : snapshot_key.slice(0, peer_start)
+}
+
+// `name@1.0.0(peer@2.0.0)` → `name`; a scoped name keeps its leading `@`.
+function name_of(key: string): string {
+	const package_key = to_package_key(key)
+	const at = package_key.indexOf(SCOPE_PREFIX, 1)
+
+	return at === -1 ? package_key : package_key.slice(0, at)
+}
+
+function without_versions(value: unknown): unknown {
+	if (Array.isArray(value)) return value.map((item: unknown) => without_versions(item))
+	if (typeof value !== 'object' || value === null) return value
+
+	const kept = Object.entries(value).filter(([key]) => key !== VERSION_KEY)
+
+	return Object.fromEntries(kept.map(([key, item]) => [key, without_versions(item)]))
+}
+
+// What a document holds besides its resolutions: a change here is no resolution of other versions.
+function skeleton_of(document: LockfileDocument): unknown {
+	const rest = Object.entries(document).filter(([key]) => !RESOLUTION_KEYS.has(key))
+
+	return { ...Object.fromEntries(rest), importers: without_versions(document.importers) }
+}
+
+function moved_keys(before: Entries, after: Entries): Array<string> {
+	const keys = new Set([...Object.keys(before), ...Object.keys(after)])
+
+	return [...keys].filter((key) => !isDeepStrictEqual(before[key], after[key]))
+}
+
+function dependency_names(snapshot: unknown): Array<string> {
+	const parsed = snapshot_schema.safeParse(snapshot ?? {})
+	if (!parsed.success) return []
+
+	return DEPENDENCY_GROUPS.flatMap((group) => Object.keys(parsed.data[group]))
+}
+
+// Each package name with the names of the packages depending on it.
+function dependents_of(documents: ReadonlyArray<LockfileDocument>): Map<string, Set<string>> {
+	const dependents = new Map<string, Set<string>>()
+	const snapshots = documents.flatMap((document) => Object.entries(document.snapshots))
+	const edges = snapshots.flatMap(([key, snapshot]) =>
+		dependency_names(snapshot).map((name) => [name, name_of(key)] as const),
+	)
+
+	for (const [name, dependent] of edges) {
+		dependents.set(name, (dependents.get(name) ?? new Set()).add(dependent))
+	}
+
+	return dependents
+}
+
+function with_dependents(
+	moved: ReadonlyArray<string>,
+	dependents: ReadonlyMap<string, ReadonlySet<string>>,
+): Set<string> {
+	const reached = new Set(moved)
+	const pending = [...reached]
+
+	for (let name = pending.pop(); name !== undefined; name = pending.pop()) {
+		const unseen = [...(dependents.get(name) ?? [])].filter((dependent) => !reached.has(dependent))
+
+		for (const dependent of unseen) reached.add(dependent)
+		pending.push(...unseen)
+	}
+
+	return reached
+}
+
+function moved_names(was: LockfileDocument, is: LockfileDocument): Array<string> {
+	return [...moved_keys(was.packages, is.packages), ...moved_keys(was.snapshots, is.snapshots)].map(
+		(key) => name_of(key),
+	)
+}
+
+function is_resolution_only(
+	was: ReadonlyArray<LockfileDocument>,
+	is: ReadonlyArray<LockfileDocument>,
+): boolean {
+	if (was.length !== is.length) return false
+
+	return was.every((document, index) => {
+		const other = is[index]
+
+		return other !== undefined && isDeepStrictEqual(skeleton_of(document), skeleton_of(other))
+	})
+}
+
+// The packages the change from `before` to `after` moved, with every package depending on one —
+// `undefined` when the change reaches every test.
+function affected_packages(before: string, after: string): ReadonlySet<string> | undefined {
+	const was = documents_of(before)
+	const is = documents_of(after)
+
+	if (was === undefined || is === undefined || !is_resolution_only(was, is)) return undefined
+
+	const moved = was.flatMap((document, index) => moved_names(document, is[index] ?? document))
+	const reached = with_dependents(moved, dependents_of([...was, ...is]))
+
+	return [...reached].some((name) => whole_suite_files.is_unit_runtime_package(name))
+		? undefined
+		: reached
+}
+
+const lockfile_changed_packages = { LOCKFILE_PATH, affected_packages, to_package_key }
+
+export { lockfile_changed_packages }

package/scripts/test/package-version-only.ts

@@ -0,0 +1,30 @@
+import { isDeepStrictEqual } from 'node:util'
+import { json_value } from '#scripts/lib/json-value'
+
+// **`package.json` is a whole-suite file only for what is not its `version`** (joshuafolkken/kit#7538).
+// The release commit moves the version alone, which neither dependency resolution nor the vitest
+// config reads, so such a change reaches the tests reading `package.json` through the test-read map
+// rather than every test. Any other key — a dependency, a script, the `pnpm` field — still runs the
+// whole suite.
+
+const PACKAGE_PATH = 'package.json'
+const VERSION_KEY = 'version'
+
+function without_version(text: string): Record<string, unknown> | undefined {
+	const value = json_value.parse_or_undefined(text)
+	if (!json_value.is_record(value)) return undefined
+
+	return Object.fromEntries(Object.entries(value).filter(([key]) => key !== VERSION_KEY))
+}
+
+// Whether the two texts differ in `version` alone — false when either is not a JSON object.
+function is_version_only(before: string, after: string): boolean {
+	const was = without_version(before)
+	const is = without_version(after)
+
+	return was !== undefined && is !== undefined && isDeepStrictEqual(was, is)
+}
+
+const package_version_only = { PACKAGE_PATH, is_version_only }
+
+export { package_version_only }

package/scripts/test/pure-files-entries.ts

@@ -1,6 +1,4 @@
 import path from 'node:path'
-import { git_command } from '#scripts/git/git-command'
-import { file_reader } from '#scripts/lib/read-file'
 
 // **`tools/test/pure-files.ts` is a whole-suite file only for what is not its entries**
 // (joshuafolkken/kit#5001). The vitest config imports it, so `vitest related` widens to every test on
@@ -54,30 +52,6 @@ function tests_of(entries: ReadonlyArray<string>): ReadonlyArray<string> {
 	return [...LIST_TESTS, ...entries]
 }
 
-async function base_text(): Promise<string | undefined> {
-	try {
-		return await git_command.show_file(`${await git_command.change_base()}:${PURE_FILES_PATH}`)
-	} catch {
-		return undefined
-	}
-}
-
-// The entries this branch moved in the list against its change base, or `undefined` when the list did
-// not change, changed beyond its entries, or either side cannot be read.
-async function read_moved(
-	root: string,
-	changed: ReadonlyArray<string> | undefined,
-): Promise<ReadonlyArray<string> | undefined> {
-	if (changed?.includes(PURE_FILES_PATH) !== true) return undefined
-
-	const before = await base_text()
-	const after = file_reader.read_if_readable(path.join(root, PURE_FILES_PATH))
-
-	if (before === undefined || after === undefined) return undefined
-
-	return moved_entries(before, after)
-}
-
-const pure_files_entries = { PURE_FILES_PATH, moved_entries, read_moved, tests_of }
+const pure_files_entries = { PURE_FILES_PATH, moved_entries, tests_of }
 
 export { pure_files_entries }

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 { lockfile_changed_packages } from './lockfile-changed-packages'
 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'
@@ -16,7 +17,8 @@ import { whole_suite_files } from './whole-suite-files'
 // 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
+// depends on — `package.json` only when more than its `version` moved (joshuafolkken/kit#7538),
+// `pnpm-lock.yaml` only when it moved a unit runtime package or more than resolutions (joshuafolkken/kit#7554) — 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
@@ -51,6 +53,7 @@ const RELATABLE_EXTENSIONS: ReadonlySet<string> = new Set([
 ])
 
 const { WHOLE_SUITE_FILES } = whole_suite_files
+const { LOCKFILE_PATH } = lockfile_changed_packages
 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'
@@ -109,6 +112,13 @@ interface ScopeRequest {
 	// 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 whole-suite files whose change is their `version` alone — `package.json` on a release
+	// commit (`package-version-only.ts`) — resolved through the map rather than the whole suite.
+	version_only?: ReadonlySet<string>
+	// The modules importing a package a `pnpm-lock.yaml` change moved, when it moved no unit runtime
+	// package (`lockfile-changed-packages.ts`) — handed to vitest, and the lockfile resolved through the
+	// map, rather than the whole suite.
+	lockfile_importers?: 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>>
@@ -242,13 +252,27 @@ function direct_selection(request: ScopeRequest, changed: ReadonlyArray<string>)
 	return { files: tests.flat(), unread: moved.filter((_file, index) => tests[index]?.length === 0) }
 }
 
+function is_resolved_elsewhere(request: ScopeRequest, file: string): boolean {
+	if (file === LOCKFILE_PATH) return request.lockfile_importers !== undefined
+
+	return request.version_only?.has(file) === true
+}
+
+function is_whole_suite_trigger(request: ScopeRequest, file: string): boolean {
+	if (is_resolved_elsewhere(request, file)) return false
+
+	return WHOLE_SUITE_FILES.has(file) && !is_narrowed(request, file) && is_moved(request, file)
+}
+
+// **A `package.json` moved in `version` alone is no trigger** (joshuafolkken/kit#7538), **nor a
+// `pnpm-lock.yaml` moving no unit runtime package** (joshuafolkken/kit#7554): each reaches the tests
+// reading it through the map, as any other non-code file does, and the lockfile also the modules
+// importing a package it moved.
 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),
-	)
+	return changed.filter((file) => is_whole_suite_trigger(request, file))
 }
 
 function resolve_read(
@@ -287,8 +311,9 @@ 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)
+	const lockfile_importers = request.lockfile_importers ?? []
 
-	return resolve_read({ ...request, changed: pure.unread }, pure.files)
+	return resolve_read({ ...request, changed: pure.unread }, [...pure.files, ...lockfile_importers])
 }
 
 function describe_scope(scope: RelatedScope, root: string): string {

package/scripts/test/test-related.ts

@@ -7,7 +7,6 @@ import { since_green, type FallbackReason } from '#scripts/gate/since-green'
 import { changed_file_scope } from '#scripts/git/changed-file-scope'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { direct_importers } from './direct-importers'
-import { pure_files_entries } from './pure-files-entries'
 import { test_no_base } from './test-no-base'
 import { test_read_map, type ReadMap } from './test-read-map'
 import { test_related_cap, type CappedImporters } from './test-related-cap'
@@ -21,6 +20,7 @@ import { test_related_synced } from './test-related-synced'
 import { test_related_touched } from './test-related-touched'
 import { test_related_verdict } from './test-related-verdict'
 import { test_related_whole } from './test-related-whole'
+import { whole_suite_narrowing } from './whole-suite-narrowing'
 
 // `josh test:related` — the unit check an implementation loop runs between edits.
 // The narrowing itself is `test-related-scope.ts` over the shared
@@ -236,14 +236,14 @@ async function scope_of(
 ): Promise<RelatedScope> {
 	const recorded = await recorded_files(change)
 	const naming = naming_moved(root, change)
-	const pure_entries = await pure_files_entries.read_moved(root, change.changed)
+	const narrowing = await whole_suite_narrowing.read(root, change.changed)
 
 	return related_scope.resolve_scope({
 		root,
 		...change,
+		...narrowing,
 		recorded,
 		naming_moved: naming,
-		pure_entries,
 		every_test_importers: capped.importers,
 		is_present: existsSync,
 	})

package/scripts/test/test-unit-guard.ts

@@ -186,21 +186,21 @@ function isolated_unit_environment(
 //
 // **The machine is read only when no count was typed.** The reading waits out a sample window, and a
 // caller's `--maxWorkers` wins whatever it says. The gate's cap is one: its admission narrows it to the
-// free cores, and its unit step bounds it by the free memory once admitted (`gate-run-steps.ts`).
+// free cores, and its unit step bounds it by the free memory once admitted (`gate-run-steps.ts`); a
+// sharing run admitted on a claim is bounded the same way (`unit_worker_share.admitted_capacity`).
 async function vitest_share(vitest_arguments: ReadonlyArray<string>): Promise<number | undefined> {
 	if (unit_worker_share.has_worker_flag(vitest_arguments)) return undefined
 
 	const available_cores = availableParallelism()
+	const live_runs = unit_worker_share.live_run_count()
+	const live_lanes = unit_worker_share.live_lane_count()
+	const claim = core_budget.held_unit_claim()
 	// The cores and the memory free right now (joshuafolkken/kit#4528), from one reading.
-	const free = await free_cores.read({ available_cores })
-	const share = unit_worker_share.current_share(
-		available_cores,
-		unit_worker_share.live_run_count(),
-		free,
-		unit_worker_share.live_lane_count(),
-	)
+	const reading = await free_cores.read({ available_cores })
+	const free = unit_worker_share.admitted_capacity(reading, claim, live_runs, live_lanes)
+	const share = unit_worker_share.current_share(available_cores, live_runs, free, live_lanes)
 
-	return unit_worker_share.cap_to_claim(share, core_budget.held_unit_claim())
+	return unit_worker_share.cap_to_claim(share, claim)
 }
 
 async function execute_vitest(

package/scripts/test/unit-worker-share.ts

@@ -109,6 +109,26 @@ function own_run(): number {
 	return is_nested_run() ? 0 : SOLO_RUNS
 }
 
+// **A sharing run's admitted claim is not cut to the free cores** (joshuafolkken/kit#7551). Under
+// concurrency the claim is already this run's slice of the machine, admitted against the ledger and
+// the load. The free cores read afterwards count the other lanes' use beyond their claims and the load
+// average's trailing minute, so a two-worker share fell to one while the ledger kept the second core
+// held for nobody — `test:related` ran 38 s alone and 71 s beside three lanes with no core wait. The
+// gate's unit step is already bounded only by the free memory once admitted; so is this. A solo run and
+// a run with no claim keep both bounds.
+function admitted_capacity(
+	free: FreeCapacity,
+	claim: UnitClaim | undefined,
+	live_runs: number,
+	live_lanes: number,
+): FreeCapacity {
+	const is_sharing = sharing_runs(live_runs + own_run(), live_lanes) > SOLO_RUNS
+
+	if (claim === undefined || !is_sharing) return free
+
+	return { cores: undefined, memory_workers: free.memory_workers }
+}
+
 // The share this run may take, read from the machine. Separate from `resolve_unit_workers` so that
 // one stays a pure function of two numbers and every test of it can pass them.
 //
@@ -180,6 +200,7 @@ const unit_worker_share = {
 	...unit_run_marker,
 	...unit_lane_count,
 	MAIN_PROCESS_CORES,
+	admitted_capacity,
 	cap_to_capacity,
 	cap_to_claim,
 	cap_to_free,