ava 5.3.0 → 6.0.0

package/lib/watcher.js

@@ -1,476 +1,605 @@
+import fs from 'node:fs';
 import nodePath from 'node:path';
+import process from 'node:process';
+import v8 from 'node:v8';
 
-import chokidar_ from 'chokidar';
+import {nodeFileTrace} from '@vercel/nft';
 import createDebug from 'debug';
 
 import {chalk} from './chalk.js';
-import {applyTestFileFilter, classify, getChokidarIgnorePatterns} from './globs.js';
+import {applyTestFileFilter, classify, buildIgnoreMatcher, findTests} from './globs.js';
+import {levels as providerLevels} from './provider-manager.js';
 
-let chokidar = chokidar_;
-export function _testOnlyReplaceChokidar(replacement) {
-	chokidar = replacement;
-}
-
-let debug = createDebug('ava:watcher');
-export function _testOnlyReplaceDebug(replacement) {
-	debug = replacement('ava:watcher');
-}
+const debug = createDebug('ava:watcher');
 
-function rethrowAsync(error) {
-	// Don't swallow exceptions. Note that any
-	// expected error should already have been logged
-	setImmediate(() => {
-		throw error;
-	});
-}
+// In order to get reliable code coverage for the tests of the watcher, we need
+// to make Node.js write out interim reports in various places.
+const takeCoverageForSelfTests = process.env.TEST_AVA ? v8.takeCoverage : undefined;
 
-const MIN_DEBOUNCE_DELAY = 10;
-const INITIAL_DEBOUNCE_DELAY = 100;
 const END_MESSAGE = chalk.gray('Type `r` and press enter to rerun tests\nType `u` and press enter to update snapshots\n');
 
-class Debouncer {
-	constructor(watcher) {
-		this.watcher = watcher;
-		this.timer = null;
-		this.repeat = false;
-	}
-
-	debounce(delay) {
-		if (this.timer) {
-			this.again = true;
-			return;
+export function available(projectDir) {
+	try {
+		fs.watch(projectDir, {recursive: true, signal: AbortSignal.abort()});
+	} catch (error) {
+		if (error.code === 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM') {
+			return false;
 		}
 
-		delay = delay ? Math.max(delay, MIN_DEBOUNCE_DELAY) : INITIAL_DEBOUNCE_DELAY;
-
-		const timer = setTimeout(async () => {
-			await this.watcher.busy;
-			// Do nothing if debouncing was canceled while waiting for the busy
-			// promise to fulfil
-			if (this.timer !== timer) {
-				return;
-			}
-
-			if (this.again) {
-				this.timer = null;
-				this.again = false;
-				this.debounce(delay / 2);
-			} else {
-				this.watcher.runAfterChanges();
-				this.timer = null;
-				this.again = false;
-			}
-		}, delay);
-
-		this.timer = timer;
+		throw error;
 	}
 
-	cancel() {
-		if (this.timer) {
-			clearTimeout(this.timer);
-			this.timer = null;
-			this.again = false;
-		}
-	}
+	return true;
 }
 
-class TestDependency {
-	constructor(file, dependencies) {
-		this.file = file;
-		this.dependencies = dependencies;
-	}
-
-	contains(dependency) {
-		return this.dependencies.includes(dependency);
+export async function start({api, filter, globs, projectDir, providers, reporter, stdin, signal}) {
+	providers = providers.filter(({level}) => level >= providerLevels.ava6);
+	for await (const {files, ...runtimeOptions} of plan({api, filter, globs, projectDir, providers, stdin, abortSignal: signal})) {
+		await api.run({files, filter, runtimeOptions});
+		reporter.endRun();
+		reporter.lineWriter.writeLine(END_MESSAGE);
 	}
 }
 
-export default class Watcher {
-	constructor({api, filter = [], globs, projectDir, providers, reporter}) {
-		this.debouncer = new Debouncer(this);
-
-		this.clearLogOnNextRun = true;
-		this.runVector = 0;
-		this.previousFiles = [];
-		this.globs = {cwd: projectDir, ...globs};
+async function * plan({api, filter, globs, projectDir, providers, stdin, abortSignal}) {
+	const fileTracer = new FileTracer({base: projectDir});
+	const isIgnored = buildIgnoreMatcher(globs);
+	const patternFilters = filter.map(({pattern}) => pattern);
 
-		const patternFilters = filter.map(({pattern}) => pattern);
-
-		this.providers = providers;
-		this.run = (specificFiles = [], updateSnapshots = false) => {
-			const clearLogOnNextRun = this.clearLogOnNextRun && this.runVector > 0;
-			if (this.runVector > 0) {
-				this.clearLogOnNextRun = true;
-			}
-
-			this.runVector++;
-
-			let runOnlyExclusive = false;
-			if (specificFiles.length > 0) {
-				const exclusiveFiles = specificFiles.filter(file => this.filesWithExclusiveTests.includes(file));
-				runOnlyExclusive = exclusiveFiles.length !== this.filesWithExclusiveTests.length;
-				if (runOnlyExclusive) {
-					// The test files that previously contained exclusive tests are always
-					// run, together with the remaining specific files.
-					const remainingFiles = specificFiles.filter(file => !exclusiveFiles.includes(file));
-					specificFiles = [...this.filesWithExclusiveTests, ...remainingFiles];
-				}
+	const statsCache = new Map();
+	const fileStats = path => {
+		if (statsCache.has(path)) {
+			return statsCache.get(path); // N.B. `undefined` is a valid value!
+		}
 
-				if (filter.length > 0) {
-					specificFiles = applyTestFileFilter({
-						cwd: projectDir,
-						expandDirectories: false,
-						filter: patternFilters,
-						testFiles: specificFiles,
-						treatFilterPatternsAsFiles: false,
-					});
+		const stats = fs.statSync(nodePath.join(projectDir, path), {throwIfNoEntry: false});
+		statsCache.set(path, stats);
+		return stats;
+	};
+
+	const fileExists = path => fileStats(path) !== undefined;
+	const cwdAndGlobs = {cwd: projectDir, ...globs};
+	const changeFromPath = path => {
+		const {isTest} = classify(path, cwdAndGlobs);
+		const stats = fileStats(path);
+		return {path, isTest, exists: stats !== undefined, isFile: stats?.isFile() ?? false};
+	};
+
+	// Begin a file trace in the background.
+	fileTracer.update(findTests(cwdAndGlobs).then(testFiles => testFiles.map(path => ({
+		path: nodePath.relative(projectDir, path),
+		isTest: true,
+		exists: true,
+	}))));
+
+	// State tracked for test runs.
+	const filesWithExclusiveTests = new Set();
+	const touchedFiles = new Set();
+	const temporaryFiles = new Set();
+	const failureCounts = new Map();
+
+	// Observe all test runs.
+	api.on('run', ({status}) => {
+		status.on('stateChange', evt => {
+			switch (evt.type) {
+				case 'accessed-snapshots': {
+					fileTracer.addDependency(nodePath.relative(projectDir, evt.testFile), nodePath.relative(projectDir, evt.filename));
+					break;
 				}
 
-				this.pruneFailures(specificFiles);
-			}
-
-			this.touchedFiles.clear();
-			this.previousFiles = specificFiles;
-			this.busy = api.run({
-				files: specificFiles,
-				filter,
-				runtimeOptions: {
-					clearLogOnNextRun,
-					previousFailures: this.sumPreviousFailures(this.runVector),
-					runOnlyExclusive,
-					runVector: this.runVector,
-					updateSnapshots: updateSnapshots === true,
-				},
-			})
-				.then(runStatus => {
-					reporter.endRun();
-					reporter.lineWriter.writeLine(END_MESSAGE);
-
-					if (this.clearLogOnNextRun && (
-						runStatus.stats.failedHooks > 0
-						|| runStatus.stats.failedTests > 0
-						|| runStatus.stats.failedWorkers > 0
-						|| runStatus.stats.internalErrors > 0
-						|| runStatus.stats.timeouts > 0
-						|| runStatus.stats.uncaughtExceptions > 0
-						|| runStatus.stats.unhandledRejections > 0
-					)) {
-						this.clearLogOnNextRun = false;
+				case 'touched-files': {
+					for (const file of evt.files.changedFiles) {
+						touchedFiles.add(nodePath.relative(projectDir, file));
 					}
-				})
-				.catch(rethrowAsync);
-		};
 
-		this.testDependencies = [];
-		this.trackTestDependencies(api);
+					for (const file of evt.files.temporaryFiles) {
+						temporaryFiles.add(nodePath.relative(projectDir, file));
+					}
 
-		this.temporaryFiles = new Set();
-		this.touchedFiles = new Set();
-		this.trackTouchedFiles(api);
+					break;
+				}
 
-		this.filesWithExclusiveTests = [];
-		this.trackExclusivity(api);
+				case 'hook-failed':
+				case 'internal-error':
+				case 'process-exit':
+				case 'test-failed':
+				case 'uncaught-exception':
+				case 'unhandled-rejection':
+				case 'worker-failed': {
+					failureCounts.set(evt.testFile, 1 + (failureCounts.get(evt.testFile) ?? 0));
+					break;
+				}
 
-		this.filesWithFailures = [];
-		this.trackFailures(api);
+				case 'worker-finished': {
+					const fileStats = status.stats.byFile.get(evt.testFile);
+					if (fileStats.selectedTests > 0 && fileStats.declaredTests > fileStats.selectedTests) {
+						filesWithExclusiveTests.add(nodePath.relative(projectDir, evt.testFile));
+					} else {
+						filesWithExclusiveTests.delete(nodePath.relative(projectDir, evt.testFile));
+					}
 
-		this.dirtyStates = {};
-		this.watchFiles();
-		this.rerunAll();
-	}
+					break;
+				}
 
-	watchFiles() {
-		chokidar.watch(['**/*'], {
-			cwd: this.globs.cwd,
-			ignored: getChokidarIgnorePatterns(this.globs),
-			ignoreInitial: true,
-		}).on('all', (event, path) => {
-			if (event === 'add' || event === 'change' || event === 'unlink') {
-				debug('Detected %s of %s', event, path);
-				this.dirtyStates[nodePath.join(this.globs.cwd, path)] = event;
-				this.debouncer.debounce();
+				default: {
+					break;
+				}
 			}
 		});
-	}
+	});
 
-	trackTestDependencies(api) {
-		api.on('run', plan => {
-			plan.status.on('stateChange', evt => {
-				if (evt.type !== 'dependencies') {
-					return;
-				}
+	// State for subsequent test runs.
+	let signalChanged;
+	let changed = Promise.resolve({});
+	let firstRun = true;
+	let runAll = true;
+	let updateSnapshots = false;
 
-				const dependencies = evt.dependencies.filter(filePath => {
-					const {isIgnoredByWatcher} = classify(filePath, this.globs);
-					return !isIgnoredByWatcher;
-				});
-				this.updateTestDependencies(evt.testFile, dependencies);
-			});
+	const reset = () => {
+		changed = new Promise(resolve => {
+			signalChanged = resolve;
 		});
-	}
+		firstRun = false;
+		runAll = false;
+		updateSnapshots = false;
+	};
+
+	// Support interactive commands.
+	stdin.setEncoding('utf8');
+	stdin.on('data', data => {
+		data = data.trim().toLowerCase();
+		runAll ||= data === 'r';
+		updateSnapshots ||= data === 'u';
+		if (runAll || updateSnapshots) {
+			signalChanged({});
+		}
+	});
+	stdin.unref();
+
+	// Whether tests are currently running. Used to control when the next run
+	// is prepared.
+	let testsAreRunning = false;
+
+	// Tracks file paths we know have changed since the previous test run.
+	const dirtyPaths = new Set();
+	const debounce = setTimeout(() => {
+		// The callback is invoked for a variety of reasons, not necessarily because
+		// there are dirty paths. But if there are none, then there's nothing to do.
+		if (dirtyPaths.size === 0) {
+			takeCoverageForSelfTests?.();
+			return;
+		}
 
-	updateTestDependencies(file, dependencies) {
-		// Ensure the rewritten test file path is included in the dependencies,
-		// since changes to non-rewritten paths are ignored.
-		for (const {main} of this.providers) {
-			const rewritten = main.resolveTestFile(file);
-			if (!dependencies.includes(rewritten)) {
-				dependencies = [rewritten, ...dependencies];
-			}
+		// Equally, if tests are currently running, then keep accumulating changes.
+		// The timer is refreshed after tests finish running.
+		if (testsAreRunning) {
+			takeCoverageForSelfTests?.();
+			return;
 		}
 
-		if (dependencies.length === 0) {
-			this.testDependencies = this.testDependencies.filter(dep => dep.file !== file);
+		// If the file tracer is still analyzing dependencies, wait for that to
+		// complete.
+		if (fileTracer.busy !== null) {
+			fileTracer.busy.then(() => debounce.refresh());
+			takeCoverageForSelfTests?.();
 			return;
 		}
 
-		const isUpdate = this.testDependencies.some(dep => {
-			if (dep.file !== file) {
+		// Identify the changes.
+		const changes = [...dirtyPaths].filter(path => {
+			if (temporaryFiles.has(path)) {
+				debug('Ignoring known temporary file %s', path);
 				return false;
 			}
 
-			dep.dependencies = dependencies;
+			if (touchedFiles.has(path)) {
+				debug('Ignoring known touched file %s', path);
+				return false;
+			}
 
-			return true;
-		});
+			for (const {main} of providers) {
+				switch (main.interpretChange(nodePath.join(projectDir, path))) {
+					case main.changeInterpretations.ignoreCompiled: {
+						debug('Ignoring compilation output %s', path);
+						return false;
+					}
 
-		if (!isUpdate) {
-			this.testDependencies.push(new TestDependency(file, dependencies));
-		}
-	}
+					case main.changeInterpretations.waitForOutOfBandCompilation: {
+						if (!fileExists(path)) {
+							debug('Not waiting for out-of-band compilation of deleted %s', path);
+							return true;
+						}
+
+						debug('Waiting for out-of-band compilation of %s', path);
+						return false;
+					}
 
-	trackTouchedFiles(api) {
-		api.on('run', plan => {
-			plan.status.on('stateChange', evt => {
-				if (evt.type !== 'touched-files') {
-					return;
+					default: {
+						continue;
+					}
 				}
+			}
+
+			if (isIgnored(path)) {
+				debug('%s is ignored by patterns', path);
+				return false;
+			}
+
+			return true;
+		}).flatMap(path => {
+			const change = changeFromPath(path);
 
-				for (const file of evt.files.changedFiles) {
-					this.touchedFiles.add(file);
+			for (const {main} of providers) {
+				const sources = main.resolvePossibleOutOfBandCompilationSources(nodePath.join(projectDir, path));
+				if (sources === null) {
+					continue;
 				}
 
-				for (const file of evt.files.temporaryFiles) {
-					this.temporaryFiles.add(file);
+				if (sources.length === 1) {
+					const [source] = sources;
+					const newPath = nodePath.relative(projectDir, source);
+					if (change.exists) {
+						debug('Interpreting %s as %s', path, newPath);
+						return changeFromPath(newPath);
+					}
+
+					debug('Interpreting deleted %s as deletion of %s', path, newPath);
+					return {...changeFromPath(newPath), exists: false};
 				}
-			});
+
+				const relativeSources = sources.map(source => nodePath.relative(projectDir, source));
+				debug('Change of %s could be due to deletion of multiple source files %j', path, relativeSources);
+				return relativeSources.filter(possiblePath => fileTracer.has(possiblePath)).map(newPath => {
+					debug('Interpreting %s as deletion of %s', path, newPath);
+					return changeFromPath(newPath);
+				});
+			}
+
+			return change;
+		}).filter(change => {
+			// Filter out changes to directories. However, if a directory was deleted,
+			// we cannot tell that it used to be a directory.
+			if (change.exists && !change.isFile) {
+				debug('%s is not a file', change.path);
+				return false;
+			}
+
+			return true;
 		});
-	}
 
-	trackExclusivity(api) {
-		api.on('run', plan => {
-			plan.status.on('stateChange', evt => {
-				if (evt.type !== 'worker-finished') {
-					return;
+		// Stats only need to be cached while we identify changes.
+		statsCache.clear();
+
+		// Identify test files that need to be run next, and whether there are
+		// non-ignored file changes that mean we should run all test files.
+		const uniqueTestFiles = new Set();
+		const deletedTestFiles = new Set();
+		const nonTestFiles = [];
+		for (const {path, isTest, exists} of changes) {
+			if (!exists) {
+				debug('%s was deleted', path);
+			}
+
+			if (isTest) {
+				debug('%s is a test file', path);
+				if (exists) {
+					uniqueTestFiles.add(path);
+				} else {
+					failureCounts.delete(path); // Stop tracking failures for deleted tests.
+					deletedTestFiles.add(path);
 				}
+			} else {
+				debug('%s is not a test file', path);
+
+				const dependingTestFiles = fileTracer.traceToTestFile(path);
+				if (dependingTestFiles.length > 0) {
+					debug('%s is depended on by test files %o', path, dependingTestFiles);
+					for (const testFile of dependingTestFiles) {
+						uniqueTestFiles.add(testFile);
+					}
+				} else {
+					debug('%s is not known to be depended on by test files', path);
+					nonTestFiles.push(path);
+				}
+			}
+		}
 
-				const fileStats = plan.status.stats.byFile.get(evt.testFile);
-				const ranExclusiveTests = fileStats.selectedTests > 0 && fileStats.declaredTests > fileStats.selectedTests;
-				this.updateExclusivity(evt.testFile, ranExclusiveTests);
+		// One more pass to make sure deleted test files are not run. This is needed
+		// because test files are selected when files they depend on are changed.
+		for (const path of deletedTestFiles) {
+			uniqueTestFiles.delete(path);
+		}
+
+		// Clear state from the previous run and detected file changes.
+		dirtyPaths.clear();
+		temporaryFiles.clear();
+		touchedFiles.clear();
+
+		// In the background, update the file tracer to reflect the changes.
+		if (changes.length > 0) {
+			fileTracer.update(changes);
+		}
+
+		// Select the test files to run, and how to run them.
+		let testFiles = [...uniqueTestFiles];
+		let runOnlyExclusive = false;
+
+		if (testFiles.length > 0) {
+			const exclusiveFiles = testFiles.filter(path => filesWithExclusiveTests.has(path));
+			runOnlyExclusive = exclusiveFiles.length !== filesWithExclusiveTests.size;
+			if (runOnlyExclusive) {
+				// The test files that previously contained exclusive tests are always
+				// run, together with the test files.
+				debug('Running exclusive tests in %o', [...filesWithExclusiveTests]);
+				testFiles = [...new Set([...filesWithExclusiveTests, ...testFiles])];
+			}
+		}
+
+		if (filter.length > 0) {
+			testFiles = applyTestFileFilter({
+				cwd: projectDir,
+				expandDirectories: false,
+				filter: patternFilters,
+				testFiles,
+				treatFilterPatternsAsFiles: false,
 			});
-		});
-	}
+		}
 
-	updateExclusivity(file, hasExclusiveTests) {
-		const index = this.filesWithExclusiveTests.indexOf(file);
+		if (nonTestFiles.length > 0) {
+			debug('Non-test files changed, running all tests');
+			failureCounts.clear(); // All tests are run, so clear previous failures.
+			signalChanged({runOnlyExclusive});
+		} else if (testFiles.length > 0) {
+			// Remove previous failures for tests that will run again.
+			for (const path of testFiles) {
+				failureCounts.delete(path);
+			}
 
-		if (hasExclusiveTests && index === -1) {
-			this.filesWithExclusiveTests.push(file);
-		} else if (!hasExclusiveTests && index !== -1) {
-			this.filesWithExclusiveTests.splice(index, 1);
+			signalChanged({runOnlyExclusive, testFiles});
 		}
-	}
 
-	trackFailures(api) {
-		api.on('run', plan => {
-			this.pruneFailures(plan.files);
+		takeCoverageForSelfTests?.();
+	}, 100).unref();
 
-			const currentVector = this.runVector;
-			plan.status.on('stateChange', evt => {
-				if (!evt.testFile) {
-					return;
-				}
+	// Detect changed files.
+	fs.watch(projectDir, {recursive: true, signal: abortSignal}, (_, filename) => {
+		if (filename !== null) {
+			dirtyPaths.add(filename);
+			debug('Detected change in %s', filename);
+			debounce.refresh();
+		}
+	});
 
-				switch (evt.type) {
-					case 'hook-failed':
-					case 'internal-error':
-					case 'process-exit':
-					case 'test-failed':
-					case 'uncaught-exception':
-					case 'unhandled-rejection':
-					case 'worker-failed': {
-						this.countFailure(evt.testFile, currentVector);
-						break;
-					}
+	abortSignal.addEventListener('abort', () => {
+		signalChanged?.({});
+	});
 
-					default: {
-						break;
-					}
-				}
-			});
-		});
+	// And finally, the watch loop.
+	while (!abortSignal.aborted) {
+		const {testFiles: files = [], runOnlyExclusive = false} = await changed; // eslint-disable-line no-await-in-loop
+
+		if (abortSignal.aborted) {
+			break;
+		}
+
+		let previousFailures = 0;
+		for (const count of failureCounts.values()) {
+			previousFailures += count;
+		}
+
+		const instructions = {
+			files: files.map(file => nodePath.join(projectDir, file)),
+			firstRun, // Value is changed by refresh() so record now.
+			previousFailures,
+			runOnlyExclusive,
+			updateSnapshots, // Value is changed by refresh() so record now.
+		};
+		reset(); // Make sure the next run can be triggered.
+		testsAreRunning = true;
+		yield instructions; // Let the tests run.
+		testsAreRunning = false;
+		debounce.refresh(); // Trigger the callback, which if there were changes will run the tests again.
 	}
+}
+
+// State management for file tracer.
+class Node {
+	#children = new Map();
+	#parents = new Map();
+	isTest = false;
 
-	pruneFailures(files) {
-		const toPrune = new Set(files);
-		this.filesWithFailures = this.filesWithFailures.filter(state => !toPrune.has(state.file));
+	constructor(path) {
+		this.path = path;
 	}
 
-	countFailure(file, vector) {
-		const isUpdate = this.filesWithFailures.some(state => {
-			if (state.file !== file) {
-				return false;
-			}
+	get parents() {
+		return this.#parents.keys();
+	}
 
-			state.count++;
-			return true;
-		});
+	addChild(node) {
+		this.#children.set(node.path, node);
+		node.#addParent(this);
+	}
 
-		if (!isUpdate) {
-			this.filesWithFailures.push({
-				file,
-				vector,
-				count: 1,
-			});
-		}
+	#addParent(node) {
+		this.#parents.set(node.path, node);
 	}
 
-	sumPreviousFailures(beforeVector) {
-		let total = 0;
+	prune() {
+		for (const child of this.#children.values()) {
+			child.#removeParent(this);
+		}
 
-		for (const state of this.filesWithFailures) {
-			if (state.vector < beforeVector) {
-				total += state.count;
-			}
+		for (const parent of this.#parents.values()) {
+			parent.#removeChild(this);
 		}
+	}
 
-		return total;
+	#removeChild(node) {
+		this.#children.delete(node.path);
 	}
 
-	cleanUnlinkedTests(unlinkedTests) {
-		for (const testFile of unlinkedTests) {
-			this.updateTestDependencies(testFile, []);
-			this.updateExclusivity(testFile, false);
-			this.pruneFailures([testFile]);
-		}
+	#removeParent(node) {
+		this.#parents.delete(node.path);
 	}
+}
 
-	observeStdin(stdin) {
-		stdin.resume();
-		stdin.setEncoding('utf8');
+class Tree extends Map {
+	get(path) {
+		if (!this.has(path)) {
+			this.set(path, new Node(path));
+		}
 
-		stdin.on('data', async data => {
-			data = data.trim().toLowerCase();
-			if (data !== 'r' && data !== 'rs' && data !== 'u') {
-				return;
-			}
+		return super.get(path);
+	}
 
-			// Cancel the debouncer, it might rerun specific tests whereas *all* tests
-			// need to be rerun
-			this.debouncer.cancel();
-			await this.busy;
-			// Cancel the debouncer again, it might have restarted while waiting for
-			// the busy promise to fulfil
-			this.debouncer.cancel();
-			this.clearLogOnNextRun = false;
-			if (data === 'u') {
-				this.updatePreviousSnapshots();
-			} else {
-				this.rerunAll();
-			}
-		});
+	delete(path) {
+		const node = this.get(path);
+		node?.prune();
+		super.delete(path);
 	}
+}
 
-	rerunAll() {
-		this.dirtyStates = {};
-		this.run();
+// Track file dependencies to determine which test files to run.
+class FileTracer {
+	#base;
+	#cache = Object.create(null);
+	#pendingTrace = null;
+	#updateRunning;
+	#signalUpdateRunning;
+	#tree = new Tree();
+
+	constructor({base}) {
+		this.#base = base;
+		this.#updateRunning = new Promise(resolve => {
+			this.#signalUpdateRunning = resolve;
+		});
 	}
 
-	updatePreviousSnapshots() {
-		this.dirtyStates = {};
-		this.run(this.previousFiles, true);
+	get busy() {
+		return this.#pendingTrace;
 	}
 
-	runAfterChanges() {
-		const {dirtyStates} = this;
-		this.dirtyStates = {};
+	traceToTestFile(startingPath) {
+		const todo = [startingPath];
+		const testFiles = new Set();
+		const visited = new Set();
+		for (const path of todo) {
+			if (visited.has(path)) {
+				continue;
+			}
 
-		let dirtyPaths = Object.keys(dirtyStates).filter(path => {
-			if (this.touchedFiles.has(path)) {
-				debug('Ignoring known touched file %s', path);
-				this.touchedFiles.delete(path);
-				return false;
+			visited.add(path);
+
+			const node = this.#tree.get(path);
+			if (node === undefined) {
+				continue;
 			}
 
-			// Unlike touched files, temporary files are never cleared. We may see
-			// adds and unlinks detected separately, so we track the temporary files
-			// as long as AVA is running.
-			if (this.temporaryFiles.has(path)) {
-				debug('Ignoring known temporary file %s', path);
-				return false;
+			if (node.isTest) {
+				testFiles.add(node.path);
+			} else {
+				todo.push(...node.parents);
 			}
+		}
 
-			return true;
+		return [...testFiles];
+	}
+
+	addDependency(testFile, path) {
+		const testNode = this.#tree.get(testFile);
+		testNode.isTest = true;
+
+		const node = this.#tree.get(path);
+		testNode.addChild(node);
+	}
+
+	has(path) {
+		return this.#tree.has(path);
+	}
+
+	update(changes) {
+		const current = this.#update(changes).finally(() => {
+			if (this.#pendingTrace === current) {
+				this.#pendingTrace = null;
+				this.#updateRunning = new Promise(resolve => {
+					this.#signalUpdateRunning = resolve;
+				});
+			}
 		});
 
-		for (const {main} of this.providers) {
-			dirtyPaths = dirtyPaths.filter(path => {
-				if (main.ignoreChange(path)) {
-					debug('Ignoring changed file %s', path);
-					return false;
-				}
+		this.#pendingTrace = current;
+	}
 
-				return true;
-			});
-		}
+	async #update(changes) {
+		await this.#pendingTrace; // Guard against race conditions.
+		this.#signalUpdateRunning();
 
-		const dirtyHelpersAndSources = [];
-		const addedOrChangedTests = [];
-		const unlinkedTests = [];
-		for (const filePath of dirtyPaths) {
-			const {isIgnoredByWatcher, isTest} = classify(filePath, this.globs);
-			if (!isIgnoredByWatcher) {
+		let reuseCache = true;
+		const knownTestFiles = new Set();
+		const deletedFiles = new Set();
+		const filesToTrace = new Set();
+		for (const {path, isTest, exists} of await changes) {
+			if (exists) {
 				if (isTest) {
-					if (dirtyStates[filePath] === 'unlink') {
-						unlinkedTests.push(filePath);
-					} else {
-						addedOrChangedTests.push(filePath);
-					}
-				} else {
-					dirtyHelpersAndSources.push(filePath);
+					knownTestFiles.add(path);
 				}
+
+				filesToTrace.add(path);
+			} else {
+				deletedFiles.add(path);
 			}
+
+			// The cache can be reused as long as the changes are just for new files.
+			reuseCache &&= !this.#tree.has(path);
 		}
 
-		this.cleanUnlinkedTests(unlinkedTests);
+		// Remove deleted files from the tree.
+		for (const path of deletedFiles) {
+			this.#tree.delete(path);
+		}
 
-		// No need to rerun tests if the only change is that tests were deleted
-		if (unlinkedTests.length === dirtyPaths.length) {
-			return;
+		// Create a new cache if the old one can't be reused.
+		if (!reuseCache) {
+			this.#cache = Object.create(null);
 		}
 
-		if (dirtyHelpersAndSources.length === 0) {
-			// Run any new or changed tests
-			this.run(addedOrChangedTests);
+		// If all changes are deletions then there is no more work to do.
+		if (filesToTrace.size === 0) {
 			return;
 		}
 
-		// Try to find tests that depend on the changed source files
-		const testsByHelpersOrSource = dirtyHelpersAndSources.map(path => this.testDependencies.filter(dep => dep.contains(path)).map(dep => {
-			debug('%s is a dependency of %s', path, dep.file);
-			return dep.file;
-		})).filter(tests => tests.length > 0);
-
-		// Rerun all tests if source files were changed that could not be traced to
-		// specific tests
-		if (testsByHelpersOrSource.length !== dirtyHelpersAndSources.length) {
-			debug('Files remain that cannot be traced to specific tests: %O', dirtyHelpersAndSources);
-			debug('Rerunning all tests');
-			this.run();
-			return;
+		// Always retrace all test files, in case a file was deleted and then replaced.
+		for (const node of this.#tree.values()) {
+			if (node.isTest) {
+				filesToTrace.add(node.path);
+			}
 		}
 
-		// Run all affected tests
-		this.run([...new Set([addedOrChangedTests, testsByHelpersOrSource].flat(2))]);
+		// Trace any new and changed files.
+		const {fileList, reasons} = await nodeFileTrace([...filesToTrace], {
+			analysis: { // Only trace exact imports.
+				emitGlobs: false,
+				computeFileReferences: false,
+				evaluatePureExpressions: true,
+			},
+			base: this.#base,
+			cache: this.#cache,
+			conditions: ['node'],
+			exportsOnly: true, // Disregard "main" in package files when "exports" is present.
+			ignore: ['**/node_modules/**'], // Don't trace through installed dependencies.
+		});
+
+		// Update the tree.
+		for (const path of fileList) {
+			const node = this.#tree.get(path);
+			node.isTest = knownTestFiles.has(path);
+
+			const {parents} = reasons.get(path);
+			for (const parent of parents) {
+				const parentNode = this.#tree.get(parent);
+				parentNode.addChild(node);
+			}
+		}
 	}
 }