@depup/webpack 5.109.0-depup.0 → 5.109.2-depup.0

package/lib/cache/PackFileCacheStrategy.js

@@ -7,6 +7,7 @@
 
 const FileSystemInfo = require("../FileSystemInfo");
 const ProgressPlugin = require("../ProgressPlugin");
+const { getReferencedFilenames } = require("../serialization/FileMiddleware");
 const SerializerMiddleware = require("../serialization/SerializerMiddleware");
 const LazySet = require("../util/LazySet");
 const formatSize = require("../util/formatSize");
@@ -34,6 +35,17 @@ const {
 /** @typedef {Set<string>} Items */
 /** @typedef {Set<string>} BuildDependencies */
 /** @typedef {Map<string, PackItemInfo>} ItemInfo */
+/** @typedef {{ firstSeen: number, size: number }} UnreferencedFile */
+/** @typedef {Map<string, UnreferencedFile>} UnreferencedFiles */
+
+// Unreferenced files are kept for this long to not race concurrent builds sharing the cache directory.
+const CLEANUP_GRACE_PERIOD = 30 * 60 * 1000;
+// Records when each unreferenced file was first seen. Aging by recorded time keeps
+// orphans expiring across caches restored with refreshed modification times.
+const UNREFERENCED_FILE = "unreferenced.json";
+// A file written this recently may belong to a concurrent build that reused the name,
+// in which case the recorded time describes the previous file and must not be trusted.
+const CLEANUP_RECENT_WRITE_PERIOD = 60 * 1000;
 
 class PackContainer {
 	/**
@@ -569,6 +581,41 @@ class Pack {
 		}
 	}
 
+	/**
+	 * Drops every content whose items all expired. Unlike a partial collection this
+	 * never unpacks, so it is not limited to a single content per store and lets a
+	 * long unused cache shrink in one go instead of one pack per build.
+	 */
+	_gcExpiredContent() {
+		const now = Date.now();
+		let packCount = 0;
+		let itemCount = 0;
+		for (let loc = 0; loc < this.content.length; loc++) {
+			const content = this.content[loc];
+			if (!content) continue;
+			let expired = true;
+			for (const identifier of content.items) {
+				const info = this.itemInfo.get(identifier);
+				if (info !== undefined && now - info.lastAccess <= this.maxAge) {
+					expired = false;
+					break;
+				}
+			}
+			if (!expired) continue;
+			for (const identifier of content.items) this.itemInfo.delete(identifier);
+			this.content[loc] = undefined;
+			packCount++;
+			itemCount += content.items.size;
+		}
+		if (packCount > 0) {
+			this.logger.log(
+				"Garbage Collected %d completely expired packs with %d items",
+				packCount,
+				itemCount
+			);
+		}
+	}
+
 	/**
 	 * Find the content with the oldest item and run GC on that.
 	 * Only runs for one content to avoid large invalidation.
@@ -581,11 +628,10 @@ class Pack {
 				oldest = info;
 			}
 		}
-		if (
-			Date.now() - /** @type {PackItemInfo} */ (oldest).lastAccess >
-			this.maxAge
-		) {
-			const loc = /** @type {PackItemInfo} */ (oldest).location;
+		// collecting expired content may have left no items at all
+		if (oldest === undefined) return;
+		if (Date.now() - oldest.lastAccess > this.maxAge) {
+			const loc = oldest.location;
 			if (loc < 0) return;
 			const content = /** @type {PackContent} */ (this.content[loc]);
 			const items = new Set(content.items);
@@ -621,6 +667,7 @@ class Pack {
 		this._persistFreshContent();
 		this._optimizeSmallContent();
 		this._optimizeUnusedContent();
+		this._gcExpiredContent();
 		this._gcOldestContent();
 		for (const identifier of this.itemInfo.keys()) {
 			write(identifier);
@@ -1166,6 +1213,8 @@ class PackFileCacheStrategy {
 		});
 		/** @type {Compiler} */
 		this.compiler = compiler;
+		/** @type {IntermediateFileSystem} */
+		this.fs = fs;
 		/** @type {string} */
 		this.context = context;
 		/** @type {string} */
@@ -1182,6 +1231,10 @@ class PackFileCacheStrategy {
 		this.readonly = readonly;
 		/** @type {boolean | undefined} */
 		this.allowCollectingMemory = allowCollectingMemory;
+		// referenced names per on-disk file, versioned by mtime since concurrent
+		// processes may rewrite packs in place under the same name
+		/** @type {Map<string, { mtimeMs: number, referenced: string[] }>} */
+		this._referencedFilesCache = new Map();
 		/** @type {false | "gzip" | "brotli" | "zstd" | undefined} */
 		this.compression = compression;
 		// eslint-disable-next-line n/no-unsupported-features/node-builtins
@@ -1588,10 +1641,17 @@ class PackFileCacheStrategy {
 						/** @type {Snapshot} */
 						(this.resolveBuildDependenciesSnapshot)
 					);
+					const cleanup = this.fs.unlink !== undefined;
+					/** @type {Set<string> | undefined} */
+					const writtenFiles = cleanup ? new Set() : undefined;
+					/** @type {Set<string> | undefined} */
+					const retainedFiles = cleanup ? new Set() : undefined;
 					return this.fileSerializer
 						.serialize(content, {
 							filename: `${this.cacheLocation}/index${this._extension}`,
 							extension: `${this._extension}`,
+							writtenFiles,
+							retainedFiles,
 							logger: this.logger,
 							profile: this.profile
 						})
@@ -1608,9 +1668,17 @@ class PackFileCacheStrategy {
 								stats.count,
 								Math.round(stats.size / 1024 / 1024)
 							);
+							if (writtenFiles !== undefined) {
+								return this._cleanupUnusedFiles(
+									writtenFiles,
+									/** @type {Set<string>} */ (retainedFiles)
+								);
+							}
 						})
 						.catch((err) => {
 							this.logger.timeEnd("store pack");
+							// files may be in an unknown state after a failed store
+							this._referencedFilesCache.clear();
 							this.logger.warn(`Caching failed for pack: ${err}`);
 							this.logger.debug(err.stack);
 						});
@@ -1622,6 +1690,192 @@ class PackFileCacheStrategy {
 			}));
 	}
 
+	/**
+	 * Reads when the currently unreferenced files were first seen. A missing or
+	 * unreadable file just restarts the grace period for every orphan.
+	 * @returns {Promise<UnreferencedFiles>} first seen time and size per file name
+	 */
+	_readUnreferencedFiles() {
+		return new Promise((resolve) => {
+			this.fs.readFile(
+				`${this.cacheLocation}/${UNREFERENCED_FILE}`,
+				(err, content) => {
+					/** @type {UnreferencedFiles} */
+					const result = new Map();
+					if (err) return resolve(result);
+					try {
+						const data = JSON.parse(
+							/** @type {Buffer} */ (content).toString("utf8")
+						);
+						for (const [file, entry] of Object.entries(data)) {
+							const { firstSeen, size } = /** @type {UnreferencedFile} */ (
+								entry
+							);
+							if (typeof firstSeen === "number" && typeof size === "number") {
+								result.set(file, { firstSeen, size });
+							}
+						}
+					} catch (_err) {
+						result.clear();
+					}
+					resolve(result);
+				}
+			);
+		});
+	}
+
+	/**
+	 * Persists when the still unreferenced files were first seen. Failing to write
+	 * only costs the orphans another grace period, so errors are ignored.
+	 * @param {UnreferencedFiles} unreferenced first seen time and size per file name
+	 * @param {boolean} hadEntries whether a previous state exists that must be replaced
+	 * @returns {Promise<void>} promise
+	 */
+	_writeUnreferencedFiles(unreferenced, hadEntries) {
+		if (unreferenced.size === 0 && !hadEntries) return Promise.resolve();
+		/** @type {Record<string, UnreferencedFile>} */
+		const data = {};
+		for (const [file, entry] of unreferenced) data[file] = entry;
+		return new Promise((resolve) => {
+			this.fs.writeFile(
+				`${this.cacheLocation}/${UNREFERENCED_FILE}`,
+				JSON.stringify(data),
+				() => resolve()
+			);
+		});
+	}
+
+	/**
+	 * Deletes files from the cache directory that are no longer referenced by the
+	 * stored pack. Retained files are walked on disk since nested lazy segments
+	 * reference files not visible during serialization. Errors only log a warning.
+	 * @param {Set<string>} writtenNames names (without extension) written by this store
+	 * @param {Set<string>} retainedNames names (without extension) referenced but not rewritten
+	 * @returns {Promise<void>} promise
+	 */
+	async _cleanupUnusedFiles(writtenNames, retainedNames) {
+		this.logger.time("cleanup unused cache files");
+		const fs = this.fs;
+		const extension = this._extension;
+		const cacheLocation = this.cacheLocation;
+		const referencedFilesCache = this._referencedFilesCache;
+		try {
+			// rewritten files may reference different names now
+			for (const name of writtenNames) referencedFilesCache.delete(name);
+			/** @type {Set<string>} */
+			const liveFiles = new Set([`index${extension}`, UNREFERENCED_FILE]);
+			for (const name of writtenNames) liveFiles.add(`${name}${extension}`);
+			/** @type {string[]} */
+			const queue = [];
+			/**
+			 * Marks a file live and queues it for walking its references.
+			 * @param {string} name file name without extension
+			 */
+			const enqueue = (name) => {
+				const file = `${name}${extension}`;
+				if (liveFiles.has(file)) return;
+				liveFiles.add(file);
+				queue.push(name);
+			};
+			for (const name of retainedNames) enqueue(name);
+			while (queue.length > 0) {
+				const name = /** @type {string} */ (queue.pop());
+				const file = `${cacheLocation}/${name}${extension}`;
+				// an unchanged mtime proves the memo entry still matches the disk
+				const mtimeMs = await new Promise((resolve, reject) => {
+					fs.stat(file, (err, stats) => {
+						if (err) return reject(err);
+						resolve(
+							/** @type {number} */ (
+								/** @type {import("../util/fs").IStats} */ (stats).mtimeMs
+							)
+						);
+					});
+				});
+				const entry = referencedFilesCache.get(name);
+				let referenced;
+				if (entry !== undefined && entry.mtimeMs === mtimeMs) {
+					referenced = entry.referenced;
+				} else {
+					referenced = await getReferencedFilenames(fs, file);
+					referencedFilesCache.set(name, { mtimeMs, referenced });
+				}
+				for (const referencedName of referenced) enqueue(referencedName);
+			}
+			const files = await new Promise((resolve, reject) => {
+				fs.readdir(cacheLocation, (err, files) => {
+					if (err) return reject(err);
+					resolve(/** @type {string[]} */ (files));
+				});
+			});
+			const seenFiles = await this._readUnreferencedFiles();
+			const now = Date.now();
+			// every store rewrites the index backup, so a recorded time would age a file
+			// that is in fact new; renaming carries the previous index mtime onto it
+			const indexBackup = `index${extension}.old`;
+			/** @type {UnreferencedFiles} */
+			const stillUnreferenced = new Map();
+			let deletedCount = 0;
+			for (const file of files) {
+				if (typeof file !== "string" || liveFiles.has(file)) continue;
+				const path = `${cacheLocation}/${file}`;
+				const stats = await new Promise((resolve) => {
+					fs.stat(path, (err, stats) => {
+						resolve(
+							err
+								? undefined
+								: /** @type {import("../util/fs").IStats} */ (stats)
+						);
+					});
+				});
+				if (stats === undefined || !stats.isFile()) continue;
+				const size = /** @type {number} */ (stats.size);
+				const seen = seenFiles.get(file);
+				// a differing size means the name was rewritten, so it is a new orphan
+				const firstSeen =
+					seen !== undefined && seen.size === size ? seen.firstSeen : now;
+				const expireTime = now - CLEANUP_GRACE_PERIOD;
+				const mtimeMs = /** @type {number} */ (stats.mtimeMs);
+				// either signal is enough: modification times are lost when a cache is
+				// restored, and recorded times are lost when the cache directory is new
+				const expired =
+					mtimeMs <= expireTime ||
+					(file !== indexBackup &&
+						firstSeen <= expireTime &&
+						mtimeMs <= now - CLEANUP_RECENT_WRITE_PERIOD);
+				if (expired) {
+					const deleted = await new Promise((resolve) => {
+						/** @type {NonNullable<IntermediateFileSystem["unlink"]>} */
+						(fs.unlink)(path, (err) => resolve(!err));
+					});
+					if (deleted) {
+						deletedCount++;
+						continue;
+					}
+				}
+				if (file !== indexBackup) {
+					stillUnreferenced.set(file, { firstSeen, size });
+				}
+			}
+			await this._writeUnreferencedFiles(stillUnreferenced, seenFiles.size > 0);
+			// drop entries of files that are no longer alive
+			for (const name of referencedFilesCache.keys()) {
+				if (!liveFiles.has(`${name}${extension}`)) {
+					referencedFilesCache.delete(name);
+				}
+			}
+			if (deletedCount > 0) {
+				this.logger.log("Deleted %d unused cache files", deletedCount);
+			}
+		} catch (err) {
+			this.logger.warn(
+				`Cleanup of unused cache files failed: ${/** @type {Error} */ (err)}`
+			);
+			this.logger.debug(/** @type {Error} */ (err).stack);
+		}
+		this.logger.timeEnd("cleanup unused cache files");
+	}
+
 	clear() {
 		this.fileSystemInfo.clear();
 		this.buildDependencies.clear();

package/lib/config/defaults.js

@@ -511,7 +511,13 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		/** @type {NonNullable<WebpackOptionsNormalized["loader"]>} */ (
 			options.loader
 		),
-		{ targetProperties, environment: options.output.environment }
+		{
+			targetProperties,
+			environment: options.output.environment,
+			outputModule:
+				/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
+				(options.output.module)
+		}
 	);
 
 	F(options, "externalsType", () => {
@@ -2251,9 +2257,13 @@ const applyExternalsPresetsDefaults = (
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Environment} options.environment environment
+ * @param {boolean} options.outputModule is output type is module
  * @returns {void}
  */
-const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
+const applyLoaderDefaults = (
+	loader,
+	{ targetProperties, environment, outputModule }
+) => {
 	F(loader, "target", () => {
 		if (targetProperties) {
 			if (targetProperties.electron) {
@@ -2267,6 +2277,15 @@ const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
 			if (targetProperties.bun) return "bun";
 			if (targetProperties.node) return "node";
 			if (targetProperties.web) return "web";
+			// no single platform to report: the bundle runs on both (target
+			// `"universal"` / `["web", "node"]`), so loaders get `"universal"`
+			if (
+				outputModule &&
+				targetProperties.node === null &&
+				targetProperties.web === null
+			) {
+				return "universal";
+			}
 		}
 	});
 	D(loader, "environment", environment);

package/lib/container/HoistContainerReferencesPlugin.js

@@ -38,12 +38,13 @@ class HoistContainerReferences {
 			const depsToTrace = new Set();
 			/** @type {Set<Dependency>} */
 			const entryExternalsToHoist = new Set();
-			hooks.addContainerEntryDependency.tap(PLUGIN_NAME, (dep) => {
+			// Both hooks feed the same trace set, so they share one callback.
+			/** @type {(dep: Dependency) => void} */
+			const traceDep = (dep) => {
 				depsToTrace.add(dep);
-			});
-			hooks.addFederationRuntimeDependency.tap(PLUGIN_NAME, (dep) => {
-				depsToTrace.add(dep);
-			});
+			};
+			hooks.addContainerEntryDependency.tap(PLUGIN_NAME, traceDep);
+			hooks.addFederationRuntimeDependency.tap(PLUGIN_NAME, traceDep);
 
 			compilation.hooks.addEntry.tap(PLUGIN_NAME, (entryDep) => {
 				if (entryDep.type === "entry") {
@@ -76,46 +77,26 @@ class HoistContainerReferences {
 	 * @param {Set<Dependency>} entryExternalsToHoist Set of container entry dependencies to hoist.
 	 */
 	hoistModulesInChunks(compilation, depsToTrace, entryExternalsToHoist) {
-		const { chunkGraph, moduleGraph } = compilation;
+		const { moduleGraph } = compilation;
 
-		// loop over entry points
+		// Entry externals: hoist the external modules (e.g. RemoteModule) they reference.
 		for (const dep of entryExternalsToHoist) {
 			const entryModule = moduleGraph.getModule(dep);
 			if (!entryModule) continue;
-			// get all the external module types and hoist them to the runtime chunk, this will get RemoteModule externals
 			const allReferencedModules = getAllReferencedModules(
 				compilation,
 				entryModule,
 				"external",
 				false
 			);
-
-			const containerRuntimes = chunkGraph.getModuleRuntimes(entryModule);
-			/** @type {Set<string>} */
-			const runtimes = new Set();
-
-			for (const runtimeSpec of containerRuntimes) {
-				forEachRuntime(runtimeSpec, (runtimeKey) => {
-					if (runtimeKey) {
-						runtimes.add(runtimeKey);
-					}
-				});
-			}
-
-			for (const runtime of runtimes) {
-				const runtimeChunk = compilation.namedChunks.get(runtime);
-				if (!runtimeChunk) continue;
-
-				for (const module of allReferencedModules) {
-					if (!chunkGraph.isModuleInChunk(module, runtimeChunk)) {
-						chunkGraph.connectChunkAndModule(runtimeChunk, module);
-					}
-				}
-			}
-			this.cleanUpChunks(compilation, allReferencedModules);
+			this.hoistReferencedModules(
+				compilation,
+				entryModule,
+				allReferencedModules
+			);
 		}
 
-		// handle container entry specifically
+		// Container entries: hoist the initial graph plus its external references.
 		for (const dep of depsToTrace) {
 			const containerEntryModule = moduleGraph.getModule(dep);
 			if (!containerEntryModule) continue;
@@ -125,43 +106,54 @@ class HoistContainerReferences {
 				"initial",
 				false
 			);
-
 			const allRemoteReferences = getAllReferencedModules(
 				compilation,
 				containerEntryModule,
 				"external",
 				false
 			);
-
 			for (const remote of allRemoteReferences) {
 				allReferencedModules.add(remote);
 			}
+			this.hoistReferencedModules(
+				compilation,
+				containerEntryModule,
+				allReferencedModules
+			);
+		}
+	}
 
-			const containerRuntimes =
-				chunkGraph.getModuleRuntimes(containerEntryModule);
-			/** @type {Set<string>} */
-			const runtimes = new Set();
-
-			for (const runtimeSpec of containerRuntimes) {
-				forEachRuntime(runtimeSpec, (runtimeKey) => {
-					if (runtimeKey) {
-						runtimes.add(runtimeKey);
-					}
-				});
-			}
+	/**
+	 * Connect `referencedModules` into each runtime chunk of `entryModule`, then
+	 * prune the chunks they were hoisted out of. The two passes above build
+	 * `referencedModules` differently but hoist them identically.
+	 * @param {Compilation} compilation The webpack compilation instance.
+	 * @param {Module} entryModule The module whose runtimes receive the modules.
+	 * @param {Set<Module>} referencedModules The modules to hoist.
+	 */
+	hoistReferencedModules(compilation, entryModule, referencedModules) {
+		const { chunkGraph } = compilation;
+		/** @type {Set<string>} */
+		const runtimes = new Set();
+		for (const runtimeSpec of chunkGraph.getModuleRuntimes(entryModule)) {
+			forEachRuntime(runtimeSpec, (runtimeKey) => {
+				if (runtimeKey) {
+					runtimes.add(runtimeKey);
+				}
+			});
+		}
 
-			for (const runtime of runtimes) {
-				const runtimeChunk = compilation.namedChunks.get(runtime);
-				if (!runtimeChunk) continue;
+		for (const runtime of runtimes) {
+			const runtimeChunk = compilation.namedChunks.get(runtime);
+			if (!runtimeChunk) continue;
 
-				for (const module of allReferencedModules) {
-					if (!chunkGraph.isModuleInChunk(module, runtimeChunk)) {
-						chunkGraph.connectChunkAndModule(runtimeChunk, module);
-					}
+			for (const module of referencedModules) {
+				if (!chunkGraph.isModuleInChunk(module, runtimeChunk)) {
+					chunkGraph.connectChunkAndModule(runtimeChunk, module);
 				}
 			}
-			this.cleanUpChunks(compilation, allReferencedModules);
 		}
+		this.cleanUpChunks(compilation, referencedModules);
 	}
 
 	/**

package/lib/container/ModuleFederationPlugin.js

@@ -18,11 +18,21 @@ const HoistContainerReferences = require("./HoistContainerReferencesPlugin");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncHook<Dependency>}
+	 * @since 5.96.0
+	 */
+	addContainerEntryDependency: new SyncHook(["dependency"]),
+	/**
+	 * @type {SyncHook<Dependency>}
+	 * @since 5.96.0
+	 */
+	addFederationRuntimeDependency: new SyncHook(["dependency"])
+});
+
 /**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncHook<Dependency>} addContainerEntryDependency
- * @property {SyncHook<Dependency>} addFederationRuntimeDependency
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
  */
 
 const PLUGIN_NAME = "ModuleFederationPlugin";
@@ -111,11 +121,7 @@ class ModuleFederationPlugin {
 }
 
 ModuleFederationPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			addContainerEntryDependency: new SyncHook(["dependency"]),
-			addFederationRuntimeDependency: new SyncHook(["dependency"])
-		})
+	createCompilationHooks
 );
 
 module.exports = ModuleFederationPlugin;

package/lib/css/CssGenerator.js

@@ -33,6 +33,7 @@ const CssImportDependency = require("../dependencies/CssImportDependency");
 const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
 
 const { encodeMappings } = require("../util/createMappings");
+const { contextifySourceUrl } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const {
 	PUBLIC_PATH_FULL_HASH,
@@ -549,8 +550,13 @@ class CssGenerator extends Generator {
 				}
 
 				const generatedJs = /** @type {string} */ (source.source());
-				const sourceName = module.readableIdentifier(
-					compilation.requestShortener
+				// Context-relative identifier, like `NormalModule.createSource` — so
+				// `SourceMapDevToolPlugin` can match the module and apply the
+				// devtool filename template instead of leaking this raw name
+				const sourceName = contextifySourceUrl(
+					/** @type {string} */ (compilation.options.context),
+					module.identifier(),
+					compilation.compiler.root
 				);
 
 				if (

package/lib/css/CssLoadingRuntimeModule.js

@@ -20,12 +20,31 @@ const { chunkHasCss } = require("./CssModulesPlugin");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.66.0
+	 */
+	createStylesheet: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.91.0
+	 */
+	linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.91.0
+	 */
+	linkPrefetch: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.107.0
+	 */
+	linkInsert: new SyncWaterfallHook(["source", "chunk"])
+});
+
 /**
- * @typedef {object} CssLoadingRuntimeModulePluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} createStylesheet
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
- * @property {SyncWaterfallHook<[string, Chunk]>} linkInsert
+ * @typedef {ReturnType<typeof createCompilationHooks>} CssLoadingRuntimeModulePluginHooks
  */
 
 class CssLoadingRuntimeModule extends RuntimeModule {
@@ -577,13 +596,7 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 }
 
 CssLoadingRuntimeModule.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CssLoadingRuntimeModulePluginHooks} */ ({
-			createStylesheet: new SyncWaterfallHook(["source", "chunk"]),
-			linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-			linkPrefetch: new SyncWaterfallHook(["source", "chunk"]),
-			linkInsert: new SyncWaterfallHook(["source", "chunk"])
-		})
+	createCompilationHooks
 );
 
 module.exports = CssLoadingRuntimeModule;