webpack 5.49.0 → 5.51.2

package/lib/FileSystemInfo.js

@@ -10,12 +10,13 @@ const asyncLib = require("neo-async");
 const AsyncQueue = require("./util/AsyncQueue");
 const StackedCacheMap = require("./util/StackedCacheMap");
 const createHash = require("./util/createHash");
-const { join, dirname, relative } = require("./util/fs");
+const { join, dirname, relative, lstatReadlinkAbsolute } = require("./util/fs");
 const makeSerializable = require("./util/makeSerializable");
 const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 const supportsEsm = +process.versions.modules >= 83;
@@ -41,17 +42,52 @@ const INVALID = Symbol("invalid");
  * @typedef {Object} FileSystemInfoEntry
  * @property {number} safeTime
  * @property {number=} timestamp
+ */
+
+/**
+ * @typedef {Object} ResolvedContextFileSystemInfoEntry
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ */
+
+/**
+ * @typedef {Object} ContextFileSystemInfoEntry
+ * @property {number} safeTime
  * @property {string=} timestampHash
+ * @property {ResolvedContextFileSystemInfoEntry=} resolved
+ * @property {Set<string>=} symlinks
  */
 
 /**
  * @typedef {Object} TimestampAndHash
  * @property {number} safeTime
  * @property {number=} timestamp
+ * @property {string} hash
+ */
+
+/**
+ * @typedef {Object} ResolvedContextTimestampAndHash
+ * @property {number} safeTime
  * @property {string=} timestampHash
  * @property {string} hash
  */
 
+/**
+ * @typedef {Object} ContextTimestampAndHash
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ * @property {string} hash
+ * @property {ResolvedContextTimestampAndHash=} resolved
+ * @property {Set<string>=} symlinks
+ */
+
+/**
+ * @typedef {Object} ContextHash
+ * @property {string} hash
+ * @property {string=} resolved
+ * @property {Set<string>=} symlinks
+ */
+
 /**
  * @typedef {Object} SnapshotOptimizationEntry
  * @property {Snapshot} snapshot
@@ -175,11 +211,11 @@ class Snapshot {
 		this.fileHashes = undefined;
 		/** @type {Map<string, TimestampAndHash | string> | undefined} */
 		this.fileTshs = undefined;
-		/** @type {Map<string, FileSystemInfoEntry> | undefined} */
+		/** @type {Map<string, ResolvedContextFileSystemInfoEntry> | undefined} */
 		this.contextTimestamps = undefined;
 		/** @type {Map<string, string> | undefined} */
 		this.contextHashes = undefined;
-		/** @type {Map<string, TimestampAndHash | string> | undefined} */
+		/** @type {Map<string, ResolvedContextTimestampAndHash> | undefined} */
 		this.contextTshs = undefined;
 		/** @type {Map<string, boolean> | undefined} */
 		this.missingExistence = undefined;
@@ -771,11 +807,29 @@ const getManagedItem = (managedPath, path) => {
 };
 
 /**
- * @param {FileSystemInfoEntry} entry file system info entry
- * @returns {boolean} existence flag
+ * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
+ * @param {T | "ignore"} entry entry
+ * @returns {T["resolved"] | undefined} the resolved entry
  */
-const toExistence = entry => {
-	return Boolean(entry);
+const getResolvedTimestamp = entry => {
+	if (entry === "ignore") return undefined;
+	if (entry === null) return null;
+	if (entry.resolved !== undefined) return entry.resolved;
+	return entry.symlinks === undefined ? entry : undefined;
+};
+
+/**
+ * @param {ContextHash} entry entry
+ * @returns {string | undefined} the resolved entry
+ */
+const getResolvedHash = entry => {
+	if (entry === null) return null;
+	if (entry.resolved !== undefined) return entry.resolved;
+	return entry.symlinks === undefined ? entry.hash : undefined;
+};
+
+const addAll = (source, target) => {
+	for (const key of source) target.add(key);
 };
 
 /**
@@ -860,11 +914,11 @@ class FileSystemInfo {
 		this._fileHashes = new Map();
 		/** @type {Map<string, TimestampAndHash | string>} */
 		this._fileTshs = new Map();
-		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		/** @type {StackedCacheMap<string, ContextFileSystemInfoEntry | "ignore" | null>} */
 		this._contextTimestamps = new StackedCacheMap();
-		/** @type {Map<string, string>} */
+		/** @type {Map<string, ContextHash>} */
 		this._contextHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string>} */
+		/** @type {Map<string, ContextTimestampAndHash>} */
 		this._contextTshs = new Map();
 		/** @type {Map<string, string>} */
 		this._managedItems = new Map();
@@ -880,18 +934,24 @@ class FileSystemInfo {
 			parallelism: 10,
 			processor: this._readFileHash.bind(this)
 		});
-		/** @type {AsyncQueue<string, string, FileSystemInfoEntry | null>} */
+		/** @type {AsyncQueue<string, string, ContextFileSystemInfoEntry | null>} */
 		this.contextTimestampQueue = new AsyncQueue({
 			name: "context timestamp",
 			parallelism: 2,
 			processor: this._readContextTimestamp.bind(this)
 		});
-		/** @type {AsyncQueue<string, string, string | null>} */
+		/** @type {AsyncQueue<string, string, ContextHash | null>} */
 		this.contextHashQueue = new AsyncQueue({
 			name: "context hash",
 			parallelism: 2,
 			processor: this._readContextHash.bind(this)
 		});
+		/** @type {AsyncQueue<string, string, ContextTimestampAndHash | null>} */
+		this.contextTshQueue = new AsyncQueue({
+			name: "context hash and timestamp",
+			parallelism: 2,
+			processor: this._readContextTimestampAndHash.bind(this)
+		});
 		/** @type {AsyncQueue<string, string, string | null>} */
 		this.managedItemQueue = new AsyncQueue({
 			name: "managed item info",
@@ -1093,10 +1153,30 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function(WebpackError=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @param {function(WebpackError=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	getContextTimestamp(path, callback) {
+		const cache = this._contextTimestamps.get(path);
+		if (cache !== undefined) {
+			const resolved = getResolvedTimestamp(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextTimestamp(cache, callback);
+		}
+		this.contextTimestampQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedTimestamp(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextTimestamp(entry, callback);
+		});
+	}
+
+	/**
+	 * @param {string} path context path
+	 * @param {function(WebpackError=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @returns {void}
+	 */
+	_getUnresolvedContextTimestamp(path, callback) {
 		const cache = this._contextTimestamps.get(path);
 		if (cache !== undefined) return callback(null, cache);
 		this.contextTimestampQueue.add(path, callback);
@@ -1119,11 +1199,62 @@ class FileSystemInfo {
 	 * @returns {void}
 	 */
 	getContextHash(path, callback) {
+		const cache = this._contextHashes.get(path);
+		if (cache !== undefined) {
+			const resolved = getResolvedHash(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextHash(cache, callback);
+		}
+		this.contextHashQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedHash(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextHash(entry, callback);
+		});
+	}
+
+	/**
+	 * @param {string} path context path
+	 * @param {function(WebpackError=, ContextHash=): void} callback callback function
+	 * @returns {void}
+	 */
+	_getUnresolvedContextHash(path, callback) {
 		const cache = this._contextHashes.get(path);
 		if (cache !== undefined) return callback(null, cache);
 		this.contextHashQueue.add(path, callback);
 	}
 
+	/**
+	 * @param {string} path context path
+	 * @param {function(WebpackError=, ResolvedContextTimestampAndHash=): void} callback callback function
+	 * @returns {void}
+	 */
+	getContextTsh(path, callback) {
+		const cache = this._contextTshs.get(path);
+		if (cache !== undefined) {
+			const resolved = getResolvedTimestamp(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextTsh(cache, callback);
+		}
+		this.contextTshQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedTimestamp(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextTsh(entry, callback);
+		});
+	}
+
+	/**
+	 * @param {string} path context path
+	 * @param {function(WebpackError=, ContextTimestampAndHash=): void} callback callback function
+	 * @returns {void}
+	 */
+	_getUnresolvedContextTsh(path, callback) {
+		const cache = this._contextTshs.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.contextTshQueue.add(path, callback);
+	}
+
 	_createBuildDependenciesResolvers() {
 		const resolveContext = createResolver({
 			resolveToContext: true,
@@ -2007,11 +2138,15 @@ class FileSystemInfo {
 					);
 					for (const path of capturedDirectories) {
 						const cache = this._contextTshs.get(path);
-						if (cache !== undefined) {
-							contextTshs.set(path, cache);
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedTimestamp(cache)) !== undefined
+						) {
+							contextTshs.set(path, resolved);
 						} else {
 							jobs++;
-							this._getContextTimestampAndHash(path, (err, entry) => {
+							const callback = (err, entry) => {
 								if (err) {
 									if (this.logger) {
 										this.logger.debug(
@@ -2023,7 +2158,12 @@ class FileSystemInfo {
 									contextTshs.set(path, entry);
 									jobDone();
 								}
-							});
+							};
+							if (cache !== undefined) {
+								this._resolveContextTsh(cache, callback);
+							} else {
+								this.getContextTsh(path, callback);
+							}
 						}
 					}
 					break;
@@ -2035,11 +2175,15 @@ class FileSystemInfo {
 					);
 					for (const path of capturedDirectories) {
 						const cache = this._contextHashes.get(path);
-						if (cache !== undefined) {
-							contextHashes.set(path, cache);
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedHash(cache)) !== undefined
+						) {
+							contextHashes.set(path, resolved);
 						} else {
 							jobs++;
-							this.contextHashQueue.add(path, (err, entry) => {
+							const callback = (err, entry) => {
 								if (err) {
 									if (this.logger) {
 										this.logger.debug(
@@ -2051,7 +2195,12 @@ class FileSystemInfo {
 									contextHashes.set(path, entry);
 									jobDone();
 								}
-							});
+							};
+							if (cache !== undefined) {
+								this._resolveContextHash(cache, callback);
+							} else {
+								this.getContextHash(path, callback);
+							}
 						}
 					}
 					break;
@@ -2064,13 +2213,15 @@ class FileSystemInfo {
 						);
 					for (const path of capturedDirectories) {
 						const cache = this._contextTimestamps.get(path);
-						if (cache !== undefined) {
-							if (cache !== "ignore") {
-								contextTimestamps.set(path, cache);
-							}
-						} else {
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedTimestamp(cache)) !== undefined
+						) {
+							contextTimestamps.set(path, resolved);
+						} else if (cache !== "ignore") {
 							jobs++;
-							this.contextTimestampQueue.add(path, (err, entry) => {
+							const callback = (err, entry) => {
 								if (err) {
 									if (this.logger) {
 										this.logger.debug(
@@ -2082,7 +2233,12 @@ class FileSystemInfo {
 									contextTimestamps.set(path, entry);
 									jobDone();
 								}
-							});
+							};
+							if (cache !== undefined) {
+								this._resolveContextTimestamp(cache, callback);
+							} else {
+								this.getContextTimestamp(path, callback);
+							}
 						}
 					}
 					break;
@@ -2099,7 +2255,7 @@ class FileSystemInfo {
 				const cache = this._fileTimestamps.get(path);
 				if (cache !== undefined) {
 					if (cache !== "ignore") {
-						missingExistence.set(path, toExistence(cache));
+						missingExistence.set(path, Boolean(cache));
 					}
 				} else {
 					jobs++;
@@ -2112,7 +2268,7 @@ class FileSystemInfo {
 							}
 							jobError();
 						} else {
-							missingExistence.set(path, toExistence(entry));
+							missingExistence.set(path, Boolean(entry));
 							jobDone();
 						}
 					});
@@ -2321,17 +2477,7 @@ class FileSystemInfo {
 		 */
 		const checkFile = (path, current, snap, log = true) => {
 			if (current === snap) return true;
-			if (!current !== !snap) {
-				// If existence of item differs
-				// it's invalid
-				if (log && this._remainingLogs > 0) {
-					this._log(
-						path,
-						current ? "it didn't exist before" : "it does no longer exist"
-					);
-				}
-				return false;
-			}
+			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
 			if (current) {
 				// For existing items only
 				if (typeof startTime === "number" && current.safeTime > startTime) {
@@ -2363,6 +2509,34 @@ class FileSystemInfo {
 					}
 					return false;
 				}
+			}
+			return true;
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {ResolvedContextFileSystemInfoEntry} current current entry
+		 * @param {ResolvedContextFileSystemInfoEntry} snap entry from snapshot
+		 * @param {boolean} log log reason
+		 * @returns {boolean} true, if ok
+		 */
+		const checkContext = (path, current, snap, log = true) => {
+			if (current === snap) return true;
+			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
+			if (current) {
+				// For existing items only
+				if (typeof startTime === "number" && current.safeTime > startTime) {
+					// If a change happened after starting reading the item
+					// this may no longer be valid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`it may have changed (%d) after the start time of the snapshot (%d)`,
+							current.safeTime,
+							startTime
+						);
+					}
+					return false;
+				}
 				if (
 					snap.timestampHash !== undefined &&
 					current.timestampHash !== snap.timestampHash
@@ -2487,41 +2661,59 @@ class FileSystemInfo {
 			this._statTestedEntries += contextTimestamps.size;
 			for (const [path, ts] of contextTimestamps) {
 				const cache = this._contextTimestamps.get(path);
-				if (cache !== undefined) {
-					if (cache !== "ignore" && !checkFile(path, cache, ts)) {
+				let resolved;
+				if (
+					cache !== undefined &&
+					(resolved = getResolvedTimestamp(cache)) !== undefined
+				) {
+					if (!checkContext(path, resolved, ts)) {
 						invalid();
 						return;
 					}
-				} else {
+				} else if (cache !== "ignore") {
 					jobs++;
-					this.contextTimestampQueue.add(path, (err, entry) => {
+					const callback = (err, entry) => {
 						if (err) return invalidWithError(path, err);
-						if (!checkFile(path, entry, ts)) {
+						if (!checkContext(path, entry, ts)) {
 							invalid();
 						} else {
 							jobDone();
 						}
-					});
+					};
+					if (cache !== undefined) {
+						this._resolveContextTimestamp(cache, callback);
+					} else {
+						this.getContextTimestamp(path, callback);
+					}
 				}
 			}
 		}
 		const processContextHashSnapshot = (path, hash) => {
 			const cache = this._contextHashes.get(path);
-			if (cache !== undefined) {
-				if (cache !== "ignore" && !checkHash(path, cache, hash)) {
+			let resolved;
+			if (
+				cache !== undefined &&
+				(resolved = getResolvedHash(cache)) !== undefined
+			) {
+				if (!checkHash(path, resolved, hash)) {
 					invalid();
 					return;
 				}
 			} else {
 				jobs++;
-				this.contextHashQueue.add(path, (err, entry) => {
+				const callback = (err, entry) => {
 					if (err) return invalidWithError(path, err);
 					if (!checkHash(path, entry, hash)) {
 						invalid();
 					} else {
 						jobDone();
 					}
-				});
+				};
+				if (cache !== undefined) {
+					this._resolveContextHash(cache, callback);
+				} else {
+					this.getContextHash(path, callback);
+				}
 			}
 		};
 		if (snapshot.hasContextHashes()) {
@@ -2539,19 +2731,28 @@ class FileSystemInfo {
 					processContextHashSnapshot(path, tsh);
 				} else {
 					const cache = this._contextTimestamps.get(path);
-					if (cache !== undefined) {
-						if (cache === "ignore" || !checkFile(path, cache, tsh, false)) {
+					let resolved;
+					if (
+						cache !== undefined &&
+						(resolved = getResolvedTimestamp(cache)) !== undefined
+					) {
+						if (!checkContext(path, resolved, tsh, false)) {
 							processContextHashSnapshot(path, tsh.hash);
 						}
-					} else {
+					} else if (cache !== "ignore") {
 						jobs++;
-						this.contextTimestampQueue.add(path, (err, entry) => {
+						const callback = (err, entry) => {
 							if (err) return invalidWithError(path, err);
-							if (!checkFile(path, entry, tsh, false)) {
+							if (!checkContext(path, entry, tsh, false)) {
 								processContextHashSnapshot(path, tsh.hash);
 							}
 							jobDone();
-						});
+						};
+						if (cache !== undefined) {
+							this._resolveContextTsh(cache, callback);
+						} else {
+							this.getContextTsh(path, callback);
+						}
 					}
 				}
 			}
@@ -2564,7 +2765,7 @@ class FileSystemInfo {
 				if (cache !== undefined) {
 					if (
 						cache !== "ignore" &&
-						!checkExistence(path, toExistence(cache), existence)
+						!checkExistence(path, Boolean(cache), Boolean(existence))
 					) {
 						invalid();
 						return;
@@ -2573,7 +2774,7 @@ class FileSystemInfo {
 					jobs++;
 					this.fileTimestampQueue.add(path, (err, entry) => {
 						if (err) return invalidWithError(path, err);
-						if (!checkExistence(path, toExistence(entry), existence)) {
+						if (!checkExistence(path, Boolean(entry), Boolean(existence))) {
 							invalid();
 						} else {
 							jobDone();
@@ -2727,12 +2928,34 @@ class FileSystemInfo {
 		}
 	}
 
-	_readContextTimestamp(path, callback) {
+	/**
+	 * @template T
+	 * @template ItemType
+	 * @param {Object} options options
+	 * @param {string} options.path path
+	 * @param {function(string): ItemType} options.fromImmutablePath called when context item is an immutable path
+	 * @param {function(string): ItemType} options.fromManagedItem called when context item is a managed path
+	 * @param {function(string, string, function(Error=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
+	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromFile called when context item is a file
+	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromDirectory called when context item is a directory
+	 * @param {function(string[], ItemType[]): T} options.reduce called from all context items
+	 * @param {function(Error=, (T)=): void} callback callback
+	 */
+	_readContext(
+		{
+			path,
+			fromImmutablePath,
+			fromManagedItem,
+			fromSymlink,
+			fromFile,
+			fromDirectory,
+			reduce
+		},
+		callback
+	) {
 		this.fs.readdir(path, (err, _files) => {
 			if (err) {
 				if (err.code === "ENOENT") {
-					this._contextTimestamps.set(path, null);
-					this._cachedDeprecatedContextTimestamps = undefined;
 					return callback(null, null);
 				}
 				return callback(err);
@@ -2745,47 +2968,94 @@ class FileSystemInfo {
 				files,
 				(file, callback) => {
 					const child = join(this.fs, path, file);
-					this.fs.stat(child, (err, stat) => {
-						if (err) return callback(err);
-
-						for (const immutablePath of this.immutablePathsWithSlash) {
-							if (path.startsWith(immutablePath)) {
-								// ignore any immutable path for timestamping
-								return callback(null, null);
-							}
+					for (const immutablePath of this.immutablePathsWithSlash) {
+						if (path.startsWith(immutablePath)) {
+							// ignore any immutable path for timestamping
+							return callback(null, fromImmutablePath(immutablePath));
 						}
-						for (const managedPath of this.managedPathsWithSlash) {
-							if (path.startsWith(managedPath)) {
-								const managedItem = getManagedItem(managedPath, child);
-								if (managedItem) {
-									// construct timestampHash from managed info
-									return this.managedItemQueue.add(managedItem, (err, info) => {
-										if (err) return callback(err);
-										return callback(null, {
-											safeTime: 0,
-											timestampHash: info
-										});
-									});
-								}
+					}
+					for (const managedPath of this.managedPathsWithSlash) {
+						if (path.startsWith(managedPath)) {
+							const managedItem = getManagedItem(managedPath, child);
+							if (managedItem) {
+								// construct timestampHash from managed info
+								return this.managedItemQueue.add(managedItem, (err, info) => {
+									if (err) return callback(err);
+									return callback(null, fromManagedItem(info));
+								});
 							}
 						}
+					}
+
+					lstatReadlinkAbsolute(this.fs, child, (err, stat) => {
+						if (err) return callback(err);
+
+						if (typeof stat === "string") {
+							return fromSymlink(child, stat, callback);
+						}
 
 						if (stat.isFile()) {
-							return this.getFileTimestamp(child, callback);
+							return fromFile(child, stat, callback);
 						}
 						if (stat.isDirectory()) {
-							this.contextTimestampQueue.increaseParallelism();
-							this.getContextTimestamp(child, (err, tsEntry) => {
-								this.contextTimestampQueue.decreaseParallelism();
-								callback(err, tsEntry);
-							});
-							return;
+							return fromDirectory(child, stat, callback);
 						}
 						callback(null, null);
 					});
 				},
-				(err, tsEntries) => {
+				(err, results) => {
 					if (err) return callback(err);
+					const result = reduce(files, results);
+					callback(null, result);
+				}
+			);
+		});
+	}
+
+	_readContextTimestamp(path, callback) {
+		this._readContext(
+			{
+				path,
+				fromImmutablePath: () => null,
+				fromManagedItem: info => ({
+					safeTime: 0,
+					timestampHash: info
+				}),
+				fromSymlink: (file, target, callback) => {
+					callback(null, {
+						timestampHash: target,
+						symlinks: new Set([target])
+					});
+				},
+				fromFile: (file, stat, callback) => {
+					// Prefer the cached value over our new stat to report consistent results
+					const cache = this._fileTimestamps.get(file);
+					if (cache !== undefined)
+						return callback(null, cache === "ignore" ? null : cache);
+
+					const mtime = +stat.mtime;
+
+					if (mtime) applyMtime(mtime);
+
+					const ts = {
+						safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
+						timestamp: mtime
+					};
+
+					this._fileTimestamps.set(file, ts);
+					this._cachedDeprecatedFileTimestamps = undefined;
+					callback(null, ts);
+				},
+				fromDirectory: (directory, stat, callback) => {
+					this.contextTimestampQueue.increaseParallelism();
+					this._getUnresolvedContextTimestamp(directory, (err, tsEntry) => {
+						this.contextTimestampQueue.decreaseParallelism();
+						callback(err, tsEntry);
+					});
+				},
+				reduce: (files, tsEntries) => {
+					let symlinks = undefined;
+
 					const hash = createHash("md4");
 
 					for (const file of files) hash.update(file);
@@ -2802,6 +3072,10 @@ class FileSystemInfo {
 							hash.update("d");
 							hash.update(`${entry.timestampHash}`);
 						}
+						if (entry.symlinks !== undefined) {
+							if (symlinks === undefined) symlinks = new Set();
+							addAll(entry.symlinks, symlinks);
+						}
 						if (entry.safeTime) {
 							safeTime = Math.max(safeTime, entry.safeTime);
 						}
@@ -2813,131 +3087,326 @@ class FileSystemInfo {
 						safeTime,
 						timestampHash: digest
 					};
-
-					this._contextTimestamps.set(path, result);
-					this._cachedDeprecatedContextTimestamps = undefined;
-
-					callback(null, result);
+					if (symlinks) result.symlinks = symlinks;
+					return result;
 				}
-			);
-		});
-	}
+			},
+			(err, result) => {
+				if (err) return callback(err);
+				this._contextTimestamps.set(path, result);
+				this._cachedDeprecatedContextTimestamps = undefined;
 
-	_readContextHash(path, callback) {
-		this.fs.readdir(path, (err, _files) => {
-			if (err) {
-				if (err.code === "ENOENT") {
-					this._contextHashes.set(path, null);
-					return callback(null, null);
-				}
-				return callback(err);
+				callback(null, result);
 			}
-			const files = /** @type {string[]} */ (_files)
-				.map(file => file.normalize("NFC"))
-				.filter(file => !/^\./.test(file))
-				.sort();
-			asyncLib.map(
-				files,
-				(file, callback) => {
-					const child = join(this.fs, path, file);
-					this.fs.stat(child, (err, stat) => {
-						if (err) return callback(err);
+		);
+	}
 
-						for (const immutablePath of this.immutablePathsWithSlash) {
-							if (path.startsWith(immutablePath)) {
-								// ignore any immutable path for hashing
-								return callback(null, "");
-							}
+	_resolveContextTimestamp(entry, callback) {
+		const hashes = [];
+		let safeTime = 0;
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextTimestamp(target, (err, entry) => {
+					if (err) return callback(err);
+					if (entry && entry !== "ignore") {
+						hashes.push(entry.timestampHash);
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
 						}
-						for (const managedPath of this.managedPathsWithSlash) {
-							if (path.startsWith(managedPath)) {
-								const managedItem = getManagedItem(managedPath, child);
-								if (managedItem) {
-									// construct hash from managed info
-									return this.managedItemQueue.add(managedItem, (err, info) => {
-										if (err) return callback(err);
-										callback(null, info || "");
-									});
-								}
-							}
+						if (entry.symlinks !== undefined) {
+							for (const target of entry.symlinks) push(target);
 						}
+					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash("md4");
+				hash.update(entry.timestampHash);
+				if (entry.safeTime) {
+					safeTime = Math.max(safeTime, entry.safeTime);
+				}
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = {
+						safeTime,
+						timestampHash: /** @type {string} */ (hash.digest("hex"))
+					})
+				);
+			}
+		);
+	}
 
-						if (stat.isFile()) {
-							return this.getFileHash(child, (err, hash) => {
-								callback(err, hash || "");
-							});
-						}
-						if (stat.isDirectory()) {
-							this.contextHashQueue.increaseParallelism();
-							this.getContextHash(child, (err, hash) => {
-								this.contextHashQueue.decreaseParallelism();
-								callback(err, hash || "");
-							});
-							return;
-						}
-						callback(null, "");
+	_readContextHash(path, callback) {
+		this._readContext(
+			{
+				path,
+				fromImmutablePath: () => "",
+				fromManagedItem: info => info || "",
+				fromSymlink: (file, target, callback) => {
+					callback(null, {
+						hash: target,
+						symlinks: new Set([target])
 					});
 				},
-				(err, fileHashes) => {
-					if (err) return callback(err);
+				fromFile: (file, stat, callback) =>
+					this.getFileHash(file, (err, hash) => {
+						callback(err, hash || "");
+					}),
+				fromDirectory: (directory, stat, callback) => {
+					this.contextHashQueue.increaseParallelism();
+					this._getUnresolvedContextHash(directory, (err, hash) => {
+						this.contextHashQueue.decreaseParallelism();
+						callback(err, hash || "");
+					});
+				},
+				/**
+				 * @param {string[]} files files
+				 * @param {(string | ContextHash)[]} fileHashes hashes
+				 * @returns {ContextHash} reduced hash
+				 */
+				reduce: (files, fileHashes) => {
+					let symlinks = undefined;
 					const hash = createHash("md4");
 
 					for (const file of files) hash.update(file);
-					for (const h of fileHashes) hash.update(h);
-
-					const digest = /** @type {string} */ (hash.digest("hex"));
-
-					this._contextHashes.set(path, digest);
+					for (const entry of fileHashes) {
+						if (typeof entry === "string") {
+							hash.update(entry);
+						} else {
+							hash.update(entry.hash);
+							if (entry.symlinks) {
+								if (symlinks === undefined) symlinks = new Set();
+								addAll(entry.symlinks, symlinks);
+							}
+						}
+					}
 
-					callback(null, digest);
+					const result = {
+						hash: /** @type {string} */ (hash.digest("hex"))
+					};
+					if (symlinks) result.symlinks = symlinks;
+					return result;
 				}
-			);
-		});
+			},
+			(err, result) => {
+				if (err) return callback(err);
+				this._contextHashes.set(path, result);
+				return callback(null, result);
+			}
+		);
 	}
 
-	_getContextTimestampAndHash(path, callback) {
-		const continueWithHash = hash => {
-			const cache = this._contextTimestamps.get(path);
-			if (cache !== undefined) {
-				if (cache !== "ignore") {
-					const result = {
-						...cache,
-						hash
-					};
-					this._contextTshs.set(path, result);
-					return callback(null, result);
-				} else {
-					this._contextTshs.set(path, hash);
-					return callback(null, hash);
+	_resolveContextHash(entry, callback) {
+		const hashes = [];
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextHash(target, (err, hash) => {
+					if (err) return callback(err);
+					if (hash) {
+						hashes.push(hash.hash);
+						if (hash.symlinks !== undefined) {
+							for (const target of hash.symlinks) push(target);
+						}
+					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash("md4");
+				hash.update(entry.hash);
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
 				}
+				callback(
+					null,
+					(entry.resolved = /** @type {string} */ (hash.digest("hex")))
+				);
+			}
+		);
+	}
+
+	_readContextTimestampAndHash(path, callback) {
+		const finalize = (timestamp, hash) => {
+			const result =
+				timestamp === "ignore"
+					? hash
+					: {
+							...timestamp,
+							...hash
+					  };
+			this._contextTshs.set(path, result);
+			callback(null, result);
+		};
+		const cachedHash = this._contextHashes.get(path);
+		const cachedTimestamp = this._contextTimestamps.get(path);
+		if (cachedHash !== undefined) {
+			if (cachedTimestamp !== undefined) {
+				finalize(cachedTimestamp, cachedHash);
 			} else {
 				this.contextTimestampQueue.add(path, (err, entry) => {
-					if (err) {
-						return callback(err);
-					}
-					const result = {
-						...entry,
-						hash
-					};
-					this._contextTshs.set(path, result);
-					return callback(null, result);
+					if (err) return callback(err);
+					finalize(entry, cachedHash);
 				});
 			}
-		};
-
-		const cache = this._contextHashes.get(path);
-		if (cache !== undefined) {
-			continueWithHash(cache);
 		} else {
-			this.contextHashQueue.add(path, (err, entry) => {
-				if (err) {
-					return callback(err);
-				}
-				continueWithHash(entry);
-			});
+			if (cachedTimestamp !== undefined) {
+				this.contextHashQueue.add(path, (err, entry) => {
+					if (err) return callback(err);
+					finalize(cachedTimestamp, entry);
+				});
+			} else {
+				this._readContext(
+					{
+						path,
+						fromImmutablePath: () => null,
+						fromManagedItem: info => ({
+							safeTime: 0,
+							timestampHash: info,
+							hash: info || ""
+						}),
+						fromSymlink: (fle, target, callback) => {
+							callback(null, {
+								timestampHash: target,
+								hash: target,
+								symlinks: new Set([target])
+							});
+						},
+						fromFile: (file, stat, callback) => {
+							this._getFileTimestampAndHash(file, callback);
+						},
+						fromDirectory: (directory, stat, callback) => {
+							this.contextTshQueue.increaseParallelism();
+							this.contextTshQueue.add(directory, (err, result) => {
+								this.contextTshQueue.decreaseParallelism();
+								callback(err, result);
+							});
+						},
+						/**
+						 * @param {string[]} files files
+						 * @param {(Partial<TimestampAndHash> & Partial<ContextTimestampAndHash> | string | null)[]} results results
+						 * @returns {ContextTimestampAndHash} tsh
+						 */
+						reduce: (files, results) => {
+							let symlinks = undefined;
+
+							const tsHash = createHash("md4");
+							const hash = createHash("md4");
+
+							for (const file of files) {
+								tsHash.update(file);
+								hash.update(file);
+							}
+							let safeTime = 0;
+							for (const entry of results) {
+								if (!entry) {
+									tsHash.update("n");
+									continue;
+								}
+								if (typeof entry === "string") {
+									tsHash.update("n");
+									hash.update(entry);
+									continue;
+								}
+								if (entry.timestamp) {
+									tsHash.update("f");
+									tsHash.update(`${entry.timestamp}`);
+								} else if (entry.timestampHash) {
+									tsHash.update("d");
+									tsHash.update(`${entry.timestampHash}`);
+								}
+								if (entry.symlinks !== undefined) {
+									if (symlinks === undefined) symlinks = new Set();
+									addAll(entry.symlinks, symlinks);
+								}
+								if (entry.safeTime) {
+									safeTime = Math.max(safeTime, entry.safeTime);
+								}
+								hash.update(entry.hash);
+							}
+
+							const result = {
+								safeTime,
+								timestampHash: /** @type {string} */ (tsHash.digest("hex")),
+								hash: /** @type {string} */ (hash.digest("hex"))
+							};
+							if (symlinks) result.symlinks = symlinks;
+							return result;
+						}
+					},
+					(err, result) => {
+						if (err) return callback(err);
+						this._contextTshs.set(path, result);
+						return callback(null, result);
+					}
+				);
+			}
 		}
 	}
 
+	_resolveContextTsh(entry, callback) {
+		const hashes = [];
+		const tsHashes = [];
+		let safeTime = 0;
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextTsh(target, (err, entry) => {
+					if (err) return callback(err);
+					if (entry) {
+						hashes.push(entry.hash);
+						if (entry.timestampHash) tsHashes.push(entry.timestampHash);
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
+						}
+						if (entry.symlinks !== undefined) {
+							for (const target of entry.symlinks) push(target);
+						}
+					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash("md4");
+				const tsHash = createHash("md4");
+				hash.update(entry.hash);
+				if (entry.timestampHash) tsHash.update(entry.timestampHash);
+				if (entry.safeTime) {
+					safeTime = Math.max(safeTime, entry.safeTime);
+				}
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				tsHashes.sort();
+				for (const h of tsHashes) {
+					tsHash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = {
+						safeTime,
+						timestampHash: /** @type {string} */ (tsHash.digest("hex")),
+						hash: /** @type {string} */ (hash.digest("hex"))
+					})
+				);
+			}
+		);
+	}
+
 	_getManagedItemDirectoryInfo(path, callback) {
 		this.fs.readdir(path, (err, elements) => {
 			if (err) {