@@ -0,0 +1,5 @@
+---
+"webpack": patch
+---
+
+Read files and directories changed while unwatched afresh in watch mode.
@@ -76,6 +76,19 @@ const getCanonicalWatchOptions = (options) => {
 	return snapshot;
 };
 
+/** @typedef {Iterable<string> & { has(item: string): boolean }} Lookup */
+
+/**
+ * Returns the items as they are when they have `has`, else as a set, which
+ * also keeps a later change by the caller or a one-shot iterable from mattering.
+ * @param {Iterable<string>} items items
+ * @returns {Lookup} the items, as something with `has`
+ */
+const toLookup = (items) =>
+	typeof (/** @type {Set<string>} */ (items).has) === "function"
+		? /** @type {Set<string>} */ (items)
+		: new Set(items);
+
 class NodeWatchFileSystem {
 	/**
 	 * Creates an instance of NodeWatchFileSystem.
@@ -91,6 +104,39 @@ class NodeWatchFileSystem {
 		// `watch` replaces this with a watcher built from its own options
 		/** @type {Watchpack | null} */
 		this.watcher = null;
+		/** @type {{ files: Lookup, directories: Lookup, missing: Lookup } | undefined} */
+		this._watched = undefined;
+	}
+
+	/**
+	 * Purges what the previous call watched and this one does not: an edit to a
+	 * path nobody watches is never reported, so its cached stat and content would
+	 * be read stale once the path is watched again.
+	 * @param {Lookup} files files to watch
+	 * @param {Lookup} directories directories to watch
+	 * @param {Lookup} missing missing paths to watch
+	 * @returns {void}
+	 */
+	_purgeUnwatched(files, directories, missing) {
+		const previous = this._watched;
+		this._watched = { files, directories, missing };
+		const fs = this.inputFileSystem;
+		if (previous === undefined || !fs || !fs.purge) return;
+		/** @type {string[]} */
+		const dropped = [];
+		for (const list of [
+			previous.files,
+			previous.directories,
+			previous.missing
+		]) {
+			for (const item of list) {
+				if (!files.has(item) && !directories.has(item) && !missing.has(item)) {
+					dropped.push(item);
+				}
+			}
+		}
+		// a prefix purge scans the whole cache once per path
+		if (dropped.length > 0) fs.purge(dropped, { exact: true });
 	}
 
 	/** @type {WatchMethod} */
@@ -124,6 +170,10 @@ class NodeWatchFileSystem {
 		if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
 			throw new Error("Invalid arguments: 'callbackUndelayed'");
 		}
+		const filesLookup = toLookup(files);
+		const directoriesLookup = toLookup(directories);
+		const missingLookup = toLookup(missing);
+		this._purgeUnwatched(filesLookup, directoriesLookup, missingLookup);
 		const oldWatcher = this.watcher;
 		this.watcher = new (getWatchpack())(getCanonicalWatchOptions(options));
 
@@ -144,9 +194,6 @@ class NodeWatchFileSystem {
 			}
 			return { fileTimeInfoEntries, contextTimeInfoEntries };
 		};
-		const directoriesSet =
-			directories instanceof Set ? directories : new Set(directories);
-
 		// Watchpack reports a watched directory whenever its contents change, and
 		// `fs.purge(dir)` matches by prefix, wiping every file's stat cache with it.
 		// Only its own entry is purged; the batch's file events carry the rest.
@@ -159,7 +206,7 @@ class NodeWatchFileSystem {
 			if (!fs || !fs.purge) return;
 			if (changes) {
 				for (const item of changes) {
-					if (directoriesSet.has(item)) {
+					if (directoriesLookup.has(item)) {
 						fs.purge(item, { exact: true });
 					} else {
 						fs.purge(item);
@@ -197,7 +244,12 @@ class NodeWatchFileSystem {
 			}
 		);
 
-		this.watcher.watch({ files, directories, missing, startTime });
+		this.watcher.watch({
+			files: filesLookup,
+			directories: directoriesLookup,
+			missing: missingLookup,
+			startTime
+		});
 
 		if (oldWatcher) {
 			oldWatcher.close();
 
@@ -108,6 +108,115 @@ describe("NodeWatchFileSystem", () => {
 		expect(later.options.ignored).toEqual(["**/mutated"]);
 	});
 
+	it("purges what a later call stops watching", () => {
+		/** @type {Parameters<import("../../lib/fs/fs").Purge>[]} */
+		const purges = [];
+		const wfs = new NodeWatchFileSystem(
+			/** @type {import("../../lib/fs/fs").InputFileSystem} */ ({
+				purge: (items, options) => {
+					purges.push([items, options]);
+				}
+			})
+		);
+		const [kept, moved, dropped, directory, missing] = [
+			"a.js",
+			"b.js",
+			"c.js",
+			"directory",
+			"missing.js"
+		].map((name) => path.join(fixtures, name));
+		const start = (
+			/** @type {string[]} */ files,
+			/** @type {string[]} */ directories,
+			/** @type {string[]} */ missingFiles
+		) =>
+			watchers.push(
+				wfs.watch(
+					files,
+					directories,
+					missingFiles,
+					Date.now(),
+					{},
+					() => {},
+					() => {}
+				)
+			);
+		start([kept, moved, dropped], [directory], [missing]);
+		expect(purges).toEqual([]);
+		start([kept], [], [moved]);
+		expect(purges).toEqual([[[dropped, directory, missing], { exact: true }]]);
+		start([kept], [], [moved]);
+		expect(purges).toHaveLength(1);
+	});
+
+	it("purges what an array held when watched, though its caller changes it", () => {
+		/** @type {Parameters<import("../../lib/fs/fs").Purge>[]} */
+		const purges = [];
+		const wfs = new NodeWatchFileSystem(
+			/** @type {import("../../lib/fs/fs").InputFileSystem} */ ({
+				purge: (items, options) => {
+					purges.push([items, options]);
+				}
+			})
+		);
+		const dropped = path.join(fixtures, "c.js");
+		const files = [file, dropped];
+		watchers.push(
+			wfs.watch(
+				files,
+				[],
+				[],
+				Date.now(),
+				{},
+				() => {},
+				() => {}
+			)
+		);
+		files.pop();
+		watchers.push(
+			wfs.watch(
+				[file],
+				[],
+				[],
+				Date.now(),
+				{},
+				() => {},
+				() => {}
+			)
+		);
+		expect(purges).toEqual([[[dropped], { exact: true }]]);
+	});
+
+	it("hands watchpack a one-shot iterable it read itself", () => {
+		const wfs = new NodeWatchFileSystem(
+			/** @type {import("../../lib/fs/fs").InputFileSystem} */ ({
+				purge: () => {}
+			})
+		);
+		const start = (
+			/** @type {Iterable<string>} */ files,
+			/** @type {Iterable<string>} */ missing
+		) =>
+			watchers.push(
+				wfs.watch(
+					files,
+					[],
+					missing,
+					Date.now(),
+					{},
+					() => {},
+					() => {}
+				)
+			);
+		start([file], []);
+		// the second call compares against the first, reading these once
+		start([file].values(), [].values());
+		const watcher =
+			/** @type {InstanceType<import("watchpack")>} */
+			(wfs.watcher);
+		expect([...watcher.fileWatchers.keys()]).toEqual([file]);
+	});
+
 	it("leaves an unsupported ignored option to watchpack", () => {
 		expect(() =>
 			watch({
 
@@ -0,0 +1 @@
+module.exports = "a";
@@ -0,0 +1,6 @@
+import keys from "./sub/keys.js";
+import expected from "./sub/expected.js";
+
+it("should list a directory changed while nothing watched it", () => {
+	expect(keys).toEqual(expected);
+});
@@ -0,0 +1,15 @@
+"use strict";
+
+const path = require("path");
+
+/** @type {import("../../../../../").LoaderDefinition} */
+module.exports = function loader() {
+	const callback = this.async();
+	const directory = path.resolve(this.rootContext, "ctx");
+	this.addContextDependency(directory);
+	this.fs.readdir(directory, (err, names) => {
+		if (err) return callback(err);
+		const list = /** @type {string[]} */ (names).map(String).sort();
+		callback(null, `export default ${JSON.stringify(list)};`);
+	});
+};
@@ -0,0 +1 @@
+export default ["a.js"];
@@ -0,0 +1 @@
+export { default } from "../loader.js!./list.js";
@@ -0,0 +1 @@
+export default [];
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"webpack": patch
 +---
++
 +Read files and directories changed while unwatched afresh in watch mode.
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export { default } from "../loader.js!./list.js";`