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

package/lib/Compilation.js

@@ -21,42 +21,38 @@ const { MultiItemCache } = require("./CacheFacade");
 const Chunk = require("./Chunk");
 const ChunkGraph = require("./ChunkGraph");
 const ChunkGroup = require("./ChunkGroup");
-const ChunkRenderError = require("./ChunkRenderError");
 const ChunkTemplate = require("./ChunkTemplate");
-const CodeGenerationError = require("./CodeGenerationError");
 const CodeGenerationResults = require("./CodeGenerationResults");
 const Dependency = require("./Dependency");
 const DependencyTemplates = require("./DependencyTemplates");
 const Entrypoint = require("./Entrypoint");
 const ErrorHelpers = require("./ErrorHelpers");
 const FileSystemInfo = require("./FileSystemInfo");
-const {
-	connectChunkGroupAndChunk,
-	connectChunkGroupParentAndChild,
-	connectEntrypointAndDependOn
-} = require("./GraphHelpers");
-const {
-	makeWebpackError,
-	tryRunOrWebpackError
-} = require("./HookWebpackError");
+const LazyBarrelController = require("./LazyBarrel");
 const MainTemplate = require("./MainTemplate");
 const Module = require("./Module");
-const ModuleDependencyError = require("./ModuleDependencyError");
-const ModuleDependencyWarning = require("./ModuleDependencyWarning");
 const ModuleGraph = require("./ModuleGraph");
-const ModuleHashingError = require("./ModuleHashingError");
-const ModuleNotFoundError = require("./ModuleNotFoundError");
 const ModuleProfile = require("./ModuleProfile");
-const ModuleRestoreError = require("./ModuleRestoreError");
-const ModuleStoreError = require("./ModuleStoreError");
 const ModuleTemplate = require("./ModuleTemplate");
 const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const RuntimeTemplate = require("./RuntimeTemplate");
 const Stats = require("./Stats");
-const WebpackError = require("./WebpackError");
 const buildChunkGraph = require("./buildChunkGraph");
 const BuildCycleError = require("./errors/BuildCycleError");
+const ChunkRenderError = require("./errors/ChunkRenderError");
+const CodeGenerationError = require("./errors/CodeGenerationError");
+const {
+	makeWebpackError,
+	tryRunOrWebpackError
+} = require("./errors/HookWebpackError");
+const ModuleDependencyError = require("./errors/ModuleDependencyError");
+const ModuleDependencyWarning = require("./errors/ModuleDependencyWarning");
+const ModuleHashingError = require("./errors/ModuleHashingError");
+const ModuleNotFoundError = require("./errors/ModuleNotFoundError");
+const ModuleRestoreError = require("./errors/ModuleRestoreError");
+const ModuleStoreError = require("./errors/ModuleStoreError");
+const WebpackError = require("./errors/WebpackError");
 const { LogType, Logger } = require("./logging/Logger");
 const StatsFactory = require("./stats/StatsFactory");
 const StatsPrinter = require("./stats/StatsPrinter");
@@ -113,6 +109,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
 /** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
 /** @typedef {import("./Module").FactoryMeta} FactoryMeta */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
@@ -137,11 +134,13 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./util/Hash")} Hash */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("tapable").AsArray<T>} AsArray<T>
  */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
  */
@@ -149,12 +148,14 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 /**
+ * Defines the callback callback.
  * @callback Callback
  * @param {(WebpackError | null)=} err
  * @returns {void}
  */
 
 /**
+ * Defines the module callback callback.
  * @callback ModuleCallback
  * @param {WebpackError | null=} err
  * @param {Module | null=} result
@@ -162,6 +163,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the module factory result callback callback.
  * @callback ModuleFactoryResultCallback
  * @param {WebpackError | null=} err
  * @param {ModuleFactoryResult | null=} result
@@ -169,6 +171,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the module or module factory result callback callback.
  * @callback ModuleOrModuleFactoryResultCallback
  * @param {WebpackError | null=} err
  * @param {Module | ModuleFactoryResult | null=} result
@@ -176,6 +179,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the execute module callback callback.
  * @callback ExecuteModuleCallback
  * @param {WebpackError | null=} err
  * @param {ExecuteModuleResult | null=} result
@@ -187,6 +191,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {Record<string, Source>} CompilationAssets */
 
 /**
+ * Defines the available modules chunk group mapping type used by this module.
  * @typedef {object} AvailableModulesChunkGroupMapping
  * @property {ChunkGroup} chunkGroup
  * @property {Set<Module>} availableModules
@@ -194,6 +199,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the dependencies block like type used by this module.
  * @typedef {object} DependenciesBlockLike
  * @property {Dependency[]} dependencies
  * @property {AsyncDependenciesBlock[]} blocks
@@ -202,16 +208,20 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {Set<Chunk>} Chunks */
 
 /**
+ * Defines the chunk path data type used by this module.
  * @typedef {object} ChunkPathData
  * @property {string | number} id
  * @property {string=} name
  * @property {string} hash
  * @property {HashWithLengthFunction=} hashWithLength
+ * @property {HashWithDigestFunction=} hashWithDigest builds `[chunkhash:<digest>]` per chunk in the runtime chunk-filename map
  * @property {(Record<string, string>)=} contentHash
  * @property {(Record<string, HashWithLengthFunction>)=} contentHashWithLength
+ * @property {(Record<string, HashWithDigestFunction>)=} contentHashWithDigest builds `[contenthash:<digest>]` per chunk in the runtime chunk-filename map
  */
 
 /**
+ * Defines the chunk hash context type used by this module.
  * @typedef {object} ChunkHashContext
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -220,12 +230,14 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the runtime requirements context type used by this module.
  * @typedef {object} RuntimeRequirementsContext
  * @property {ChunkGraph} chunkGraph the chunk graph
  * @property {CodeGenerationResults} codeGenerationResults the code generation results
  */
 
 /**
+ * Defines the execute module options type used by this module.
  * @typedef {object} ExecuteModuleOptions
  * @property {EntryOptions=} entryOptions
  */
@@ -235,9 +247,11 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {EXPECTED_ANY} ExecuteModuleExports */
 
 /**
+ * Defines the execute module result type used by this module.
  * @typedef {object} ExecuteModuleResult
  * @property {ExecuteModuleExports} exports
  * @property {boolean} cacheable
+ * @property {string[]} notCacheableReasons reasons why the executed modules are not cacheable
  * @property {ExecuteModuleAssets} assets
  * @property {FileSystemDependencies} fileDependencies
  * @property {FileSystemDependencies} contextDependencies
@@ -246,6 +260,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the execute module object type used by this module.
  * @typedef {object} ExecuteModuleObject
  * @property {string=} id module id
  * @property {ExecuteModuleExports} exports exports
@@ -254,6 +269,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the execute module argument type used by this module.
  * @typedef {object} ExecuteModuleArgument
  * @property {Module} module
  * @property {ExecuteModuleObject=} moduleObject
@@ -263,6 +279,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {((id: string) => ExecuteModuleExports) & { i?: ((options: ExecuteOptions) => void)[], c?: Record<string, ExecuteModuleObject> }} WebpackRequire */
 
 /**
+ * Defines the execute options type used by this module.
  * @typedef {object} ExecuteOptions
  * @property {string=} id module id
  * @property {ExecuteModuleObject} module module
@@ -272,6 +289,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {Map<string, { source: Source, info: AssetInfo | undefined }>} ExecuteModuleAssets */
 
 /**
+ * Defines the execute module context type used by this module.
  * @typedef {object} ExecuteModuleContext
  * @property {ExecuteModuleAssets} assets
  * @property {Chunk} chunk
@@ -280,6 +298,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the entry data type used by this module.
  * @typedef {object} EntryData
  * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup
  * @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated
@@ -287,6 +306,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the log entry type used by this module.
  * @typedef {object} LogEntry
  * @property {keyof LogType} type
  * @property {EXPECTED_ANY[]=} args
@@ -295,6 +315,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * Defines the known asset info type used by this module.
  * @typedef {object} KnownAssetInfo
  * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)
  * @property {boolean=} minimized whether the asset is minimized
@@ -302,6 +323,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset
  * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset
  * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
+ * @property {Record<string, string>=} contenthashDigest maps a `[contenthash:<digest>]` value to its digest, so `RealContentHashPlugin` re-encodes the recomputed hash in it
  * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
  * @property {number=} size size in bytes, only set after asset has been emitted
  * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
@@ -316,6 +338,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {{ path: string, info: AssetInfo }} InterpolatedPathAndAssetInfo */
 
 /**
+ * Defines the asset type used by this module.
  * @typedef {object} Asset
  * @property {string} name the filename of the asset
  * @property {Source} source source of the asset
@@ -324,7 +347,10 @@ const { isSourceEqual } = require("./util/source");
 
 /** @typedef {(length: number) => string} HashWithLengthFunction */
 
+/** @typedef {(digest: string, length?: number) => string} HashWithDigestFunction */
+
 /**
+ * Defines the module path data type used by this module.
  * @typedef {object} ModulePathData
  * @property {string | number} id
  * @property {string} hash
@@ -334,10 +360,14 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {(id: string | number) => string | number} PrepareIdFunction */
 
 /**
+ * Defines the path data type used by this module.
  * @typedef {object} PathData
  * @property {ChunkGraph=} chunkGraph
  * @property {string=} hash
+ * @property {string=} fullHash untruncated compilation hash, for re-encoding `[fullhash:<digest>]`
+ * @property {string=} fullHashDigest digest `fullHash` is encoded in (defaults to `hashDigest`)
  * @property {HashWithLengthFunction=} hashWithLength
+ * @property {HashWithDigestFunction=} hashWithDigest builds `[fullhash:<digest>]`/`[hash:<digest>]` in the runtime chunk-filename context, where it throws because a runtime `getFullHash()` expression cannot be re-encoded
  * @property {(Chunk | ChunkPathData)=} chunk
  * @property {(Module | ModulePathData)=} module
  * @property {RuntimeSpec=} runtime
@@ -346,16 +376,40 @@ const { isSourceEqual } = require("./util/source");
  * @property {string=} query
  * @property {string=} contentHashType
  * @property {string=} contentHash
+ * @property {string=} contentHashFull untruncated module/asset content hash, for re-encoding `[contenthash:<digest>]` from full entropy
  * @property {HashWithLengthFunction=} contentHashWithLength
+ * @property {string=} hashDigest digest the stored hashes are encoded in (for `[hash:<digest>]`)
+ * @property {boolean=} realContentHash whether `optimization.realContentHash` recomputes content hashes (records an inline `[contenthash:<digest>]` so it re-encodes in that digest)
+ * @property {boolean=} hashAsFullHash treat `[hash]` as `[fullhash]` rather than the module hash (CSS local idents)
  * @property {boolean=} noChunkHash
  * @property {string=} url
  * @property {string=} local
+ * @property {string=} uniqueName
  * @property {PrepareIdFunction=} prepareId
  */
 
+/**
+ * Path data narrowed for the chunk filename / chunk asset interpolation context,
+ * where `chunk` is always provided. Use as the type parameter to `TemplatePathFn`
+ * for callbacks that receive a chunk context (for example `output.filename`,
+ * `output.chunkFilename`, `output.cssFilename`, `output.cssChunkFilename`,
+ * `optimization.splitChunks.cacheGroups[*].filename`).
+ * @typedef {PathData & { chunk: Chunk | ChunkPathData }} PathDataChunk
+ */
+
+/**
+ * Path data narrowed for the module asset interpolation context, where `module`
+ * and `chunkGraph` are always provided. Use as the type parameter to
+ * `TemplatePathFn` for callbacks that receive a module context (for example
+ * `output.assetModuleFilename`, the per-module `generator.filename` /
+ * `generator.outputPath`, and `module.parser.css.localIdentName`).
+ * @typedef {PathData & { module: Module | ModulePathData, chunkGraph: ChunkGraph }} PathDataModule
+ */
+
 /** @typedef {"module" | "chunk" | "root-of-chunk" | "nested"} ExcludeModulesType */
 
 /**
+ * Defines the known normalized stats options type used by this module.
  * @typedef {object} KnownNormalizedStatsOptions
  * @property {string} context
  * @property {RequestShortener} requestShortener
@@ -400,6 +454,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, EXPECTED_ANY>} NormalizedStatsOptions */
 
 /**
+ * Defines the known create stats options context type used by this module.
  * @typedef {object} KnownCreateStatsOptionsContext
  * @property {boolean=} forToString
  */
@@ -422,6 +477,7 @@ const esmDependencyCategory = "esm";
 // TODO webpack 6: remove
 const deprecatedNormalModuleLoaderHook = util.deprecate(
 	/**
+	 * Handles the callback logic for this hook.
 	 * @param {Compilation} compilation compilation
 	 * @returns {NormalModuleCompilationHooks["loader"]} hooks
 	 */
@@ -433,6 +489,7 @@ const deprecatedNormalModuleLoaderHook = util.deprecate(
 
 // TODO webpack 6: remove
 /**
+ * Define removed module templates.
  * @param {ModuleTemplates | undefined} moduleTemplates module templates
  */
 const defineRemovedModuleTemplates = (moduleTemplates) => {
@@ -481,6 +538,7 @@ const byLocation = compareSelect((err) => err.loc, compareLocations);
 const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
 /**
+ * Defines the known unsafe cache data type used by this module.
  * @typedef {object} KnownUnsafeCacheData
  * @property {FactoryMeta=} factoryMeta factory meta
  * @property {ResolveOptions=} resolveOptions resolve options
@@ -491,6 +549,7 @@ const compareErrors = concatComparators(byModule, byLocation, byMessage);
 /** @typedef {KnownUnsafeCacheData & Record<string, EXPECTED_ANY>} UnsafeCacheData */
 
 /**
+ * Defines the module with restore from unsafe cache type used by this module.
  * @typedef {Module & { restoreFromUnsafeCache?: (unsafeCacheData: UnsafeCacheData, moduleFactory: ModuleFactory, compilationParams: CompilationParams) => void }} ModuleWithRestoreFromUnsafeCache
  */
 
@@ -502,7 +561,38 @@ const unsafeCacheDependencies = new WeakMap();
 /** @type {WeakMap<ModuleWithRestoreFromUnsafeCache, UnsafeCacheData>} */
 const unsafeCacheData = new WeakMap();
 
-/** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, blocks?: (ChunkId | null)[] }} References */
+/** @typedef {EXPECTED_OBJECT} DependencyReportCacheToken */
+
+/**
+ * Renewed when the module or a transitively referenced module is rebuilt.
+ * @type {WeakMap<Module, DependencyReportCacheToken>}
+ */
+const dependencyReportCacheTokens = new WeakMap();
+
+/**
+ * Modules known to have no dependency errors/warnings, per cache token.
+ * @type {WeakMap<DependencyReportCacheToken, WeakSet<Module>>}
+ */
+const modulesWithoutProblems = new WeakMap();
+
+/**
+ * Reduce affect type.
+ * @param {Readonly<ModuleGraphConnection[]>} connections connections
+ * @returns {symbol | boolean} result
+ */
+const reduceAffectType = (connections) => {
+	let affected = false;
+	for (const { dependency } of connections) {
+		if (!dependency) continue;
+		const type = dependency.couldAffectReferencingModule();
+		if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
+		if (type === false) continue;
+		affected = true;
+	}
+	return affected;
+};
+
+/** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, blocks?: (ChunkId | null)[], sourceTypes?: SourceTypes }} References */
 /** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */
 
 class Compilation {
@@ -512,6 +602,7 @@ class Compilation {
 	 * @param {CompilationParams} params the compilation parameters
 	 */
 	constructor(compiler, params) {
+		/** @type {boolean} */
 		this._backCompat = compiler._backCompat;
 
 		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
@@ -522,6 +613,7 @@ class Compilation {
 		/** @type {Set<string>} */
 		let savedAssets = new Set();
 		/**
+		 * Returns new assets.
 		 * @param {CompilationAssets} assets assets
 		 * @returns {CompilationAssets} new assets
 		 */
@@ -554,6 +646,7 @@ class Compilation {
 				/** @type {ProcessedAssets | undefined} */
 				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
 				/**
+				 * Gets available assets.
 				 * @param {CompilationAssets} assets to be processed by additionalAssetsFn
 				 * @returns {CompilationAssets} available assets
 				 */
@@ -584,6 +677,7 @@ class Compilation {
 							...remainingTap,
 							type: "async",
 							/**
+							 * Processes the provided asset.
 							 * @param {CompilationAssets} assets assets
 							 * @param {(err?: Error | null, result?: void) => void} callback callback
 							 * @returns {void}
@@ -629,6 +723,7 @@ class Compilation {
 						return {
 							...remainingTap,
 							/**
+							 * Processes the provided asset.
 							 * @param {CompilationAssets} assets assets
 							 * @param {(err?: Error | null, result?: void) => void} callback callback
 							 * @returns {void}
@@ -637,6 +732,7 @@ class Compilation {
 								fn(
 									assets,
 									/**
+									 * Handles the callback logic for this hook.
 									 * @param {Error} err err
 									 * @returns {void}
 									 */
@@ -673,6 +769,7 @@ class Compilation {
 						return {
 							...remainingTap,
 							/**
+							 * Returns result.
 							 * @param {CompilationAssets} assets assets
 							 * @returns {Promise<CompilationAssets>} result
 							 */
@@ -700,6 +797,7 @@ class Compilation {
 		const afterProcessAssetsHook = new SyncHook(["assets"]);
 
 		/**
+		 * Creates a process assets hook.
 		 * @template T
 		 * @param {string} name name of the hook
 		 * @param {number} stage new stage
@@ -710,6 +808,7 @@ class Compilation {
 		const createProcessAssetsHook = (name, stage, getArgs, code) => {
 			if (!this._backCompat && code) return;
 			/**
+			 * Returns error message.
 			 * @param {string} reason reason
 			 * @returns {string} error message
 			 */
@@ -718,6 +817,7 @@ class Compilation {
 			) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
 			/**
+			 * Normalizes tap options for migrated process-assets hooks.
 			 * @param {string | (import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions)} options hook options
 			 * @returns {import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions} modified options
 			 */
@@ -784,9 +884,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtime"
 			]),
 
-			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			/**
+			 * @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>}
+			 * @since 5.32.0
+			 */
 			executeModule: new SyncHook(["options", "context"]),
-			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			/**
+			 * @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>}
+			 * @since 5.33.0
+			 */
 			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
 
 			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
@@ -990,7 +1096,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			processAssets: processAssetsHook,
 			afterProcessAssets: afterProcessAssetsHook,
-			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
+			/**
+			 * @type {AsyncSeriesHook<[CompilationAssets]>}
+			 * @since 5.8.0
+			 */
 			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
 			/** @type {SyncBailHook<[], boolean | void>} */
@@ -1042,6 +1151,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			statsPrinter: new SyncHook(["statsPrinter", "options"]),
 
 			/**
+			 * Gets normal module loader.
 			 * @deprecated
 			 * @returns {SyncHook<[AnyLoaderContext, NormalModule]>} normal module loader hook
 			 */
@@ -1062,6 +1172,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.inputFileSystem =
 			/** @type {InputFileSystem} */
 			(compiler.inputFileSystem);
+		/** @type {FileSystemInfo} */
 		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
 			unmanagedPaths: compiler.unmanagedPaths,
 			managedPaths: compiler.managedPaths,
@@ -1080,7 +1191,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		}
 		/** @type {ValueCacheVersions} */
 		this.valueCacheVersions = new Map();
+		/** @type {RequestShortener} */
 		this.requestShortener = compiler.requestShortener;
+		/** @type {string} */
 		this.compilerPath = compiler.compilerPath;
 
 		this.logger = this.getLogger("webpack.Compilation");
@@ -1095,9 +1208,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {boolean} */
 		this.profile = (options && options.profile) || false;
 
+		/** @type {CompilationParams} */
 		this.params = params;
+		/** @type {MainTemplate} */
 		this.mainTemplate = new MainTemplate(this.outputOptions, this);
+		/** @type {ChunkTemplate} */
 		this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
+		/** @type {RuntimeTemplate} */
 		this.runtimeTemplate = new RuntimeTemplate(
 			this,
 			this.outputOptions,
@@ -1207,6 +1324,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo = new Map();
 		/** @type {Map<string, Map<string, Set<string>>>} */
 		this._assetsRelatedIn = new Map();
+		/** @type {Map<string, Set<Chunk>> | undefined} */
+		this._assetToChunkIndex = undefined;
+		/** @type {Map<string, Set<Chunk>> | undefined} */
+		this._assetToChunkAuxiliaryIndex = undefined;
 		/** @type {Error[]} */
 		this.errors = [];
 		/** @type {Error[]} */
@@ -1259,6 +1380,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.compilationDependencies = {
 			add: util.deprecate(
 				/**
+				 * Handles the add callback for this hook.
 				 * @param {string} item item
 				 * @returns {FileSystemDependencies} file dependencies
 				 */
@@ -1268,8 +1390,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			)
 		};
 
+		/** @type {CacheFacade} */
 		this._modulesCache = this.getCache("Compilation/modules");
+		/** @type {CacheFacade} */
 		this._assetsCache = this.getCache("Compilation/assets");
+		/** @type {CacheFacade} */
 		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
 
 		const unsafeCache = options.module.unsafeCache;
@@ -1278,6 +1403,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {UnsafeCachePredicate} */
 		this._unsafeCachePredicate =
 			typeof unsafeCache === "function" ? unsafeCache : () => true;
+
+		/** @type {LazyBarrelController} */
+		this._lazyBarrelController = new LazyBarrelController(this);
 	}
 
 	getStats() {
@@ -1285,6 +1413,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Creates a stats options.
 	 * @param {string | boolean | StatsOptions | undefined} optionsOrPreset stats option value
 	 * @param {CreateStatsOptionsContext=} context context
 	 * @returns {NormalizedStatsOptions} normalized options
@@ -1318,6 +1447,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Creates a stats factory.
 	 * @param {NormalizedStatsOptions} options options
 	 * @returns {StatsFactory} the stats factory
 	 */
@@ -1328,6 +1458,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Creates a stats printer.
 	 * @param {NormalizedStatsOptions} options options
 	 * @returns {StatsPrinter} the stats printer
 	 */
@@ -1338,6 +1469,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Returns the cache facade instance.
 	 * @param {string} name cache name
 	 * @returns {CacheFacade} the cache facade instance
 	 */
@@ -1346,6 +1478,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Returns a logger with that name.
 	 * @param {string | (() => string)} name name of the logger, or function called once to get the logger name
 	 * @returns {Logger} a logger with that name
 	 */
@@ -1392,7 +1525,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						typeof console.profileEnd === "function"
 					) {
 						console.profileEnd(
-							`[${name}] ${/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]}`
+							`[${name}] ${
+								/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]
+							}`
 						);
 					}
 					if (logEntries === undefined) {
@@ -1471,6 +1606,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Adds the provided module to the compilation.
 	 * @param {Module} module module to be added that was created
 	 * @param {ModuleCallback} callback returns the module in the compilation,
 	 * it could be the passed one (if new), or an already existing in the compilation
@@ -1481,6 +1617,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Adds the provided module to the compilation.
 	 * @param {Module} module module to be added that was created
 	 * @param {ModuleCallback} callback returns the module in the compilation,
 	 * it could be the passed one (if new), or an already existing in the compilation
@@ -1630,6 +1767,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Process module dependencies.
 	 * @param {Module} module to be processed for deps
 	 * @param {ModuleCallback} callback callback to be triggered
 	 * @returns {void}
@@ -1639,11 +1777,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Process module dependencies non recursive.
 	 * @param {Module} module to be processed for deps
 	 * @returns {void}
 	 */
 	processModuleDependenciesNonRecursive(module) {
 		/**
+		 * Process dependencies block.
 		 * @param {DependenciesBlock} block block
 		 */
 		const processDependenciesBlock = (block) => {
@@ -1662,6 +1802,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Process module dependencies.
 	 * @param {Module} module to be processed for deps
 	 * @param {ModuleCallback} callback callback to be triggered
 	 * @returns {void}
@@ -1674,6 +1815,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			Dependency.isLowPriorityDependency
 		);
 
+		// lazy barrel: defer re-export targets of side-effect-free modules
+		const hasLazyBarrel = this._lazyBarrelController.classify(module);
+
 		/** @type {DependenciesBlock} */
 		let currentBlock;
 
@@ -1697,6 +1841,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let inProgressTransitive = 1;
 
 		/**
+		 * On dependencies sorted.
 		 * @param {WebpackError=} err error
 		 * @returns {void}
 		 */
@@ -1733,6 +1878,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		/**
+		 * On transitive tasks finished.
 		 * @param {WebpackError=} err error
 		 * @returns {void}
 		 */
@@ -1744,12 +1890,23 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		/**
+		 * Process dependency.
 		 * @param {Dependency} dep dependency
 		 * @param {number} index index in block
 		 * @returns {void}
 		 */
 		const processDependency = (dep, index) => {
 			this.moduleGraph.setParents(dep, currentBlock, module, index);
+			if (
+				hasLazyBarrel &&
+				// TODO remove in webpack 6
+				// It may be missing on custom dependency types not extending the base Dependency
+				"isLazy" in dep &&
+				dep.isLazy()
+			) {
+				return;
+			}
+
 			if (this._unsafeCache) {
 				try {
 					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
@@ -1763,6 +1920,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								dep,
 								unsafeCachedModule
 							);
+							this._lazyBarrelController.unlazyForDependency(
+								unsafeCachedModule,
+								dep,
+								sortedDependencies
+							);
 							return;
 						}
 						const identifier = unsafeCachedModule.identifier();
@@ -1776,6 +1938,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								dep,
 								cachedModule
 							);
+							this._lazyBarrelController.unlazyForDependency(
+								cachedModule,
+								dep,
+								sortedDependencies
+							);
 							return;
 						}
 						inProgressSorting++;
@@ -1836,6 +2003,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 									dep,
 									cachedModule
 								); // a3
+								this._lazyBarrelController.unlazyForDependency(
+									cachedModule,
+									dep,
+									sortedDependencies
+								);
 							} catch (err) {
 								if (inProgressSorting <= 0) return;
 								inProgressSorting = -1;
@@ -1855,6 +2027,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		/**
+		 * Process dependency for resolving.
 		 * @param {Dependency} dep dependency
 		 * @returns {void}
 		 */
@@ -1973,6 +2146,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Handle new module from unsafe cache.
 	 * @private
 	 * @param {Module} originModule original module
 	 * @param {Dependency} dependency dependency
@@ -2000,11 +2174,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			module,
 			true,
 			false,
+			[dependency],
 			callback
 		);
 	}
 
 	/**
+	 * Handle existing module from unsafe cache.
 	 * @private
 	 * @param {Module} originModule original modules
 	 * @param {Dependency} dependency dependency
@@ -2017,6 +2193,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Processes the provided factorize module option.
 	 * @param {FactorizeModuleOptions} options options
 	 * @param {ModuleOrModuleFactoryResultCallback} callback callback
 	 * @returns {void}
@@ -2103,18 +2280,21 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Processes the provided module callback.
 	 * @overload
 	 * @param {FactorizeModuleOptions & { factoryResult?: false }} options options
 	 * @param {ModuleCallback} callback callback
 	 * @returns {void}
 	 */
 	/**
+	 * Processes the provided module factory result callback.
 	 * @overload
 	 * @param {FactorizeModuleOptions & { factoryResult: true }} options options
 	 * @param {ModuleFactoryResultCallback} callback callback
 	 * @returns {void}
 	 */
 	/**
+	 * Processes the provided |.
 	 * @param {FactorizeModuleOptions & { factoryResult?: false } | FactorizeModuleOptions & { factoryResult: true }} options options
 	 * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
 	 */
@@ -2127,6 +2307,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Defines the handle module creation options type used by this module.
 	 * @typedef {object} HandleModuleCreationOptions
 	 * @property {ModuleFactory} factory
 	 * @property {Dependency[]} dependencies
@@ -2139,6 +2320,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 */
 
 	/**
+	 * Handle module creation.
 	 * @param {HandleModuleCreationOptions} options options object
 	 * @param {ModuleCallback} callback callback
 	 * @returns {void}
@@ -2202,7 +2384,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					applyFactoryResultDependencies();
 					return callback();
 				}
-
 				if (currentProfile !== undefined) {
 					moduleGraph.setProfile(newModule, currentProfile);
 				}
@@ -2275,6 +2456,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						module,
 						recursive,
 						checkCycle,
+						dependencies,
 						callback
 					);
 				});
@@ -2283,11 +2465,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Handle module build and dependencies.
 	 * @private
 	 * @param {Module | null} originModule original module
 	 * @param {Module} module module
 	 * @param {boolean} recursive true if make it recursive, otherwise false
 	 * @param {boolean} checkCycle true if need to check cycle, otherwise false
+	 * @param {Dependency[]} dependencies the dependencies that resolved to the module (lazy barrel)
 	 * @param {ModuleCallback} callback callback
 	 * @returns {void}
 	 */
@@ -2296,6 +2480,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		module,
 		recursive,
 		checkCycle,
+		dependencies,
 		callback
 	) {
 		// Check for cycles when build is trigger inside another build
@@ -2360,21 +2545,60 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				return;
 			}
 
-			// This avoids deadlocks for circular dependencies
-			if (this.processDependenciesQueue.isProcessing(module)) {
-				return callback(null, module);
-			}
+			// lazy barrel:
+			// 1. first call: barrel module is not classified yet, so this records the requested
+			//    ids and returns undefined; the targets get built below when
+			//    `processModuleDependencies` runs `_lazyBarrelController.classify` and replays them.
+			// 2. later call: barrel module is already built, so `processModuleDependencies` won't
+			//    re-walk it; the newly requested targets must be built here.
+			const unlazyItems = this._lazyBarrelController.request(
+				module,
+				dependencies
+			);
 
-			this.processModuleDependencies(module, (err) => {
-				if (err) {
-					return callback(err);
+			if (unlazyItems !== undefined) {
+				let inProgress = unlazyItems.length + 1; // +1 = the module's own dep processing
+				let errored = false;
+				/**
+				 * @param {(WebpackError | null)=} err error
+				 * @returns {void}
+				 */
+				const onJobDone = (err) => {
+					if (errored) return;
+					if (err) {
+						errored = true;
+						return callback(err);
+					}
+					if (--inProgress === 0) callback(null, module);
+				};
+				for (const item of unlazyItems) {
+					this.handleModuleCreation(item, (err) => {
+						onJobDone(err && this.bail ? err : null);
+					});
 				}
-				callback(null, module);
-			});
+				if (this.processDependenciesQueue.isProcessing(module)) {
+					onJobDone();
+				} else {
+					this.processModuleDependencies(module, onJobDone);
+				}
+			} else {
+				// This avoids deadlocks for circular dependencies
+				if (this.processDependenciesQueue.isProcessing(module)) {
+					return callback(null, module);
+				}
+
+				this.processModuleDependencies(module, (err) => {
+					if (err) {
+						return callback(err);
+					}
+					callback(null, module);
+				});
+			}
 		});
 	}
 
 	/**
+	 * Adds the provided string to the compilation.
 	 * @param {string} context context string path
 	 * @param {Dependency} dependency dependency used to create Module chain
 	 * @param {ModuleCallback} callback callback for when module chain is complete
@@ -2385,6 +2609,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Adds the provided object to the compilation.
 	 * @param {object} options options
 	 * @param {string} options.context context string path
 	 * @param {Dependency} options.dependency dependency used to create Module chain
@@ -2439,6 +2664,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Adds the provided string to the compilation.
 	 * @param {string} context context path for entry
 	 * @param {Dependency} entry entry dependency that should be followed
 	 * @param {string | EntryOptions} optionsOrName options or deprecated name of entry
@@ -2456,6 +2682,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Adds the provided string to the compilation.
 	 * @param {string} context context path for entry
 	 * @param {Dependency} dependency dependency that should be followed
 	 * @param {EntryOptions} options options
@@ -2473,6 +2700,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Adds the provided string to the compilation.
 	 * @param {string} context context path for entry
 	 * @param {Dependency} entry entry dependency that should be followed
 	 * @param {"dependencies" | "includeDependencies"} target type of entry
@@ -2553,6 +2781,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Processes the provided module.
 	 * @param {Module} module module to be rebuilt
 	 * @param {ModuleCallback} callback callback when module finishes rebuilding
 	 * @returns {void}
@@ -2562,6 +2791,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Processes the provided module.
 	 * @param {Module} module module to be rebuilt
 	 * @param {ModuleCallback} callback callback when module finishes rebuilding
 	 * @returns {void}
@@ -2607,6 +2837,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Compute affected modules.
 	 * @private
 	 * @param {Set<Module>} modules modules
 	 */
@@ -2629,6 +2860,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statWithoutBuild = 0;
 
 		/**
+		 * Compute references.
 		 * @param {Module} module module
 		 * @returns {WeakReferences | undefined} references
 		 */
@@ -2646,6 +2878,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		/**
+		 * Compares references.
 		 * @param {Module} module the module
 		 * @param {WeakReferences | undefined} references references
 		 * @returns {boolean} true, when the references differ
@@ -2721,21 +2954,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 		}
 
-		/**
-		 * @param {Readonly<ModuleGraphConnection[]>} connections connections
-		 * @returns {symbol | boolean} result
-		 */
-		const reduceAffectType = (connections) => {
-			let affected = false;
-			for (const { dependency } of connections) {
-				if (!dependency) continue;
-				const type = dependency.couldAffectReferencingModule();
-				if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
-				if (type === false) continue;
-				affected = true;
-			}
-			return affected;
-		};
 		/** @type {Set<Module>} */
 		const directOnlyInfectedModules = new Set();
 		for (const module of infectedModules) {
@@ -2804,6 +3022,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statChanged = 0;
 		let statNew = 0;
 		/**
+		 * Compute references.
 		 * @param {Module} module module
 		 * @returns {References} references
 		 */
@@ -2837,17 +3056,27 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					queue.push.apply(queue, block.blocks);
 				}
 			}
-			return { id, modules, blocks };
+			return {
+				id,
+				modules,
+				blocks,
+				sourceTypes: module.getReferencedSourceTypes()
+			};
 		};
 		/**
+		 * Compares references.
 		 * @param {Module} module module
 		 * @param {object} references references
 		 * @param {string | number} references.id id
 		 * @param {Map<Module, string | number | undefined>=} references.modules modules
 		 * @param {(string | number | null)[]=} references.blocks blocks
+		 * @param {SourceTypes=} references.sourceTypes connection-dependent source types
 		 * @returns {boolean} ok?
 		 */
-		const compareReferences = (module, { id, modules, blocks }) => {
+		const compareReferences = (
+			module,
+			{ id, modules, blocks, sourceTypes }
+		) => {
 			if (id !== chunkGraph.getModuleId(module)) return false;
 			if (modules !== undefined) {
 				for (const [module, id] of modules) {
@@ -2871,6 +3100,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 				if (i !== blocks.length) return false;
 			}
+			// getReferencedSourceTypes() returns interned type sets, compare by reference. #20800
+			if (
+				sourceTypes !== undefined &&
+				module.getReferencedSourceTypes() !== sourceTypes
+			) {
+				return false;
+			}
 			return true;
 		};
 
@@ -2907,6 +3143,58 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
+	 * Assigns a fresh dependency report cache token to every module whose
+	 * dependency errors/warnings could have changed since the previous
+	 * compilation: built modules and their (transitive) parents.
+	 * @private
+	 * @param {Set<Module>} modules modules
+	 * @returns {void}
+	 */
+	_flagModulesForDependencyReporting(modules) {
+		/** @type {DependencyReportCacheToken} */
+		const token = {};
+		const { moduleGraph, builtModules } = this;
+		/** @type {Set<Module>} */
+		const updatedModules = new Set();
+		for (const module of modules) {
+			if (
+				builtModules.has(module) ||
+				!dependencyReportCacheTokens.has(module)
+			) {
+				updatedModules.add(module);
+			}
+		}
+		// skip the parent walk when everything is updated anyway (initial build)
+		if (updatedModules.size !== modules.size) {
+			/** @type {Set<Module>} */
+			const directOnlyUpdatedModules = new Set();
+			for (const module of updatedModules) {
+				for (const [
+					referencingModule,
+					connections
+				] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+					if (!referencingModule) continue;
+					if (updatedModules.has(referencingModule)) continue;
+					const type = reduceAffectType(connections);
+					if (!type) continue;
+					if (type === true) {
+						directOnlyUpdatedModules.add(referencingModule);
+					} else {
+						updatedModules.add(referencingModule);
+					}
+				}
+			}
+			for (const module of directOnlyUpdatedModules) {
+				updatedModules.add(module);
+			}
+		}
+		for (const module of updatedModules) {
+			dependencyReportCacheTokens.set(module, token);
+		}
+	}
+
+	/**
+	 * Processes the provided callback.
 	 * @param {Callback} callback callback
 	 */
 	finish(callback) {
@@ -2966,6 +3254,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
 			// Avoid coverage problems due indirect changes
 			/**
+			 * Processes the provided value.
 			 * @param {number} value value
 			 * @param {string} msg message
 			 */
@@ -2984,6 +3273,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 			};
 			/**
+			 * Log normal summary.
 			 * @param {string} category a category
 			 * @param {(profile: ModuleProfile) => number} getDuration get duration callback
 			 * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback
@@ -3013,6 +3303,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				);
 			};
 			/**
+			 * Log by loaders summary.
 			 * @param {string} category a category
 			 * @param {(profile: ModuleProfile) => number} getDuration get duration callback
 			 * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback
@@ -3040,16 +3331,18 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						if (d === 0 || p === 0) continue;
 						const t = d / p;
 						innerSum += t;
-						if (t <= 10) continue;
-						logByValue(
-							t,
-							` |  | ${Math.round(t)} ms${
-								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
-							} ${category} > ${module.readableIdentifier(
-								this.requestShortener
-							)}`
-						);
-						innerMax = Math.max(innerMax, t);
+						/* istanbul ignore next -- @preserve: only slow (>10ms) modules are logged, timing-dependent */
+						if (t > 10) {
+							logByValue(
+								t,
+								` |  | ${Math.round(t)} ms${
+									p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+								} ${category} > ${module.readableIdentifier(
+									this.requestShortener
+								)}`
+							);
+							innerMax = Math.max(innerMax, t);
+						}
 					}
 					sum += innerSum;
 					if (innerSum <= 10) continue;
@@ -3120,19 +3413,28 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			// extract warnings and errors from modules
 			this.moduleGraph.freeze("dependency errors");
-			// TODO keep a cacheToken (= {}) for each module in the graph
-			// create a new one per compilation and flag all updated files
-			// and parents with it
 			this.logger.time("report dependency errors and warnings");
+			// moduleMemCaches has its own invalidation (incl. reference changes),
+			// so cache tokens are only used without it
+			const useReportCacheTokens = moduleMemCaches === undefined;
+			if (useReportCacheTokens) {
+				this._flagModulesForDependencyReporting(modules);
+			}
 			for (const module of modules) {
-				// TODO only run for modules with changed cacheToken
-				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
 				const memCache = moduleMemCaches && moduleMemCaches.get(module);
 				if (memCache && memCache.get("noWarningsOrErrors")) continue;
+				let token;
+				if (useReportCacheTokens) {
+					token = dependencyReportCacheTokens.get(module);
+					const cleanModules = modulesWithoutProblems.get(
+						/** @type {DependencyReportCacheToken} */ (token)
+					);
+					if (cleanModules !== undefined && cleanModules.has(module)) continue;
+				}
 				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
 					module
 				]);
-				const errors = module.getErrors();
+				const errors = /** @type {WebpackError[]} */ (module.getErrors());
 				if (errors !== undefined) {
 					for (const error of errors) {
 						if (!error.module) {
@@ -3142,7 +3444,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						hasProblems = true;
 					}
 				}
-				const warnings = module.getWarnings();
+				const warnings = /** @type {WebpackError[]} */ (module.getWarnings());
 				if (warnings !== undefined) {
 					for (const warning of warnings) {
 						if (!warning.module) {
@@ -3152,7 +3454,21 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						hasProblems = true;
 					}
 				}
-				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
+				if (!hasProblems) {
+					if (memCache) memCache.set("noWarningsOrErrors", true);
+					if (useReportCacheTokens) {
+						let cleanModules = modulesWithoutProblems.get(
+							/** @type {DependencyReportCacheToken} */ (token)
+						);
+						if (cleanModules === undefined) {
+							modulesWithoutProblems.set(
+								/** @type {DependencyReportCacheToken} */ (token),
+								(cleanModules = new WeakSet())
+							);
+						}
+						cleanModules.add(module);
+					}
+				}
 			}
 			this.moduleGraph.unfreeze();
 			this.logger.timeEnd("report dependency errors and warnings");
@@ -3171,17 +3487,21 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.additionalChunkAssets.length = 0;
 		this.assets = {};
 		this.assetsInfo.clear();
+		this._assetToChunkIndex = undefined;
+		this._assetToChunkAuxiliaryIndex = undefined;
 		this.moduleGraph.removeAllModuleAttributes();
 		this.moduleGraph.unfreeze();
 		this.moduleMemCaches2 = undefined;
 	}
 
 	/**
+	 * Processes the provided callback.
 	 * @param {Callback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	seal(callback) {
 		/**
+		 * Processes the provided err.
 		 * @param {WebpackError=} err err
 		 * @returns {void}
 		 */
@@ -3191,6 +3511,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.rebuildQueue.clear();
 			this.processDependenciesQueue.clear();
 			this.addModuleQueue.clear();
+			// lazy barrel only acts during make; release its bookkeeping now
+			this._lazyBarrelController.clear();
+			// unsafe-cache restore tables are only read during make; release them
+			// so they stop pinning restored modules for the rest of the compilation
+			this._restoredUnsafeCacheModuleEntries.clear();
+			this._restoredUnsafeCacheEntries.clear();
 			return callback(err);
 		};
 
@@ -3228,7 +3554,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.namedChunkGroups.set(name, entrypoint);
 			this.entrypoints.set(name, entrypoint);
 			this.chunkGroups.push(entrypoint);
-			connectChunkGroupAndChunk(entrypoint, chunk);
+
+			if (entrypoint.pushChunk(chunk)) {
+				chunk.addGroup(entrypoint);
+			}
 
 			/** @type {Set<Module>} */
 			const entryModules = new Set();
@@ -3256,6 +3585,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.assignDepths(entryModules);
 
 			/**
+			 * Returns sorted deps.
 			 * @param {Dependency[]} deps deps
 			 * @returns {Module[]} sorted deps
 			 */
@@ -3318,8 +3648,12 @@ Remove the 'runtime' option from the entrypoint.`);
 						entry.setRuntimeChunk(entryChunk);
 						continue outer;
 					}
-					connectEntrypointAndDependOn(entry, dependency);
-					connectChunkGroupParentAndChild(dependency, entry);
+
+					entry.addDependOn(dependency);
+
+					if (dependency.addChild(entry)) {
+						entry.addParent(dependency);
+					}
 				}
 			} else if (runtime) {
 				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
@@ -3556,6 +3890,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Report dependency errors and warnings.
 	 * @param {Module} module module to report from
 	 * @param {DependenciesBlock[]} blocks blocks to report from
 	 * @returns {boolean} true, when it has warnings or errors
@@ -3569,7 +3904,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				const warnings = d.getWarnings(this.moduleGraph);
 				if (warnings) {
 					for (const w of warnings) {
-						const warning = new ModuleDependencyWarning(module, w, d.loc);
+						// A consolidated dependency (e.g. CssIcssExportDependency) carries
+						// per-item locations on the error itself; fall back to the
+						// dependency loc for the usual one-loc-per-dependency case.
+						const warning = new ModuleDependencyWarning(
+							module,
+							w,
+							/** @type {EXPECTED_ANY} */ (w).loc || d.loc
+						);
 						this.warnings.push(warning);
 						hasProblems = true;
 					}
@@ -3577,7 +3919,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				const errors = d.getErrors(this.moduleGraph);
 				if (errors) {
 					for (const e of errors) {
-						const error = new ModuleDependencyError(module, e, d.loc);
+						const error = new ModuleDependencyError(
+							module,
+							e,
+							/** @type {EXPECTED_ANY} */ (e).loc || d.loc
+						);
 						this.errors.push(error);
 						hasProblems = true;
 					}
@@ -3592,6 +3938,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Generates code and runtime requirements for this module.
 	 * @param {Callback} callback callback
 	 */
 	codeGeneration(callback) {
@@ -3629,6 +3976,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Run code generation jobs.
 	 * @private
 	 * @param {CodeGenerationJobs} jobs code generation jobs
 	 * @param {Callback} callback callback
@@ -3738,6 +4086,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Code generation module.
 	 * @param {Module} module module
 	 * @param {RuntimeSpec} runtime runtime
 	 * @param {RuntimeSpec[]} runtimes runtimes
@@ -3749,6 +4098,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @param {WebpackError[]} errors errors
 	 * @param {CodeGenerationResults} results results
 	 * @param {(err?: WebpackError | null, result?: boolean) => void} callback callback
+	 * @returns {void}
 	 */
 	_codeGenerationModule(
 		module,
@@ -3764,6 +4114,39 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		callback
 	) {
 		let codeGenerated = false;
+		// without a cache backend, skip building the cache keys — the module
+		// identifier strings are large (concatenated modules join all inner ids)
+		if (!this._codeGenerationCache.isEnabled()) {
+			/** @type {CodeGenerationResult} */
+			let result;
+			try {
+				codeGenerated = true;
+				this.codeGeneratedModules.add(module);
+				result = module.codeGeneration({
+					chunkGraph,
+					moduleGraph,
+					dependencyTemplates,
+					runtimeTemplate,
+					runtime,
+					runtimes,
+					codeGenerationResults: results,
+					compilation: this
+				});
+			} catch (err) {
+				errors.push(
+					new CodeGenerationError(module, /** @type {Error} */ (err))
+				);
+				result = {
+					sources: new Map(),
+					runtimeRequirements: null,
+					data: undefined
+				};
+			}
+			for (const runtime of runtimes) {
+				results.add(module, runtime, result);
+			}
+			return callback(null, codeGenerated);
+		}
 		const cache = new MultiItemCache(
 			runtimes.map((runtime) =>
 				this._codeGenerationCache.getItemCache(
@@ -3796,7 +4179,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					);
 					result = cachedResult = {
 						sources: new Map(),
-						runtimeRequirements: null
+						runtimeRequirements: null,
+						data: undefined
 					};
 				}
 			} else {
@@ -3830,6 +4214,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Process runtime requirements.
 	 * @param {object} options options
 	 * @param {ChunkGraph=} options.chunkGraph the chunk graph
 	 * @param {Iterable<Module>=} options.modules modules
@@ -3973,6 +4358,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	// TODO webpack 6 make chunkGraph argument non-optional
 	/**
+	 * Adds runtime module.
 	 * @param {Chunk} chunk target chunk
 	 * @param {RuntimeModule} module runtime module
 	 * @param {ChunkGraph} chunkGraph the chunk graph
@@ -4065,7 +4451,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		const chunk = this.addChunk(name);
 
-		connectChunkGroupAndChunk(chunkGroup, chunk);
+		if (chunkGroup.pushChunk(chunk)) {
+			chunk.addGroup(chunkGroup);
+		}
 
 		this.chunkGroups.push(chunkGroup);
 		if (name) {
@@ -4075,6 +4463,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Adds the provided async entrypoint to this chunk group.
 	 * @param {EntryOptions} options options for the entrypoint
 	 * @param {Module} module the module the references the chunk group
 	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
@@ -4108,7 +4497,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		this.chunkGroups.push(entrypoint);
 		this.asyncEntrypoints.push(entrypoint);
-		connectChunkGroupAndChunk(entrypoint, chunk);
+		if (entrypoint.pushChunk(chunk)) {
+			chunk.addGroup(entrypoint);
+		}
 		if (module) {
 			entrypoint.addOrigin(module, loc, request);
 		}
@@ -4140,6 +4531,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Processes the provided module.
 	 * @deprecated
 	 * @param {Module} module module to assign depth
 	 * @returns {void}
@@ -4154,6 +4546,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		moduleGraph.setDepth(module, 0);
 
 		/**
+		 * Processes the provided module.
 		 * @param {Module} module module for processing
 		 * @returns {void}
 		 */
@@ -4176,7 +4569,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
-	 * @param {Module[] | Set<Module>} modules module to assign depth
+	 * Assigns depth values to the provided modules.
+	 * @param {Module[] | Set<Module>} modules modules to assign depth
 	 * @returns {void}
 	 */
 	assignDepths(modules) {
@@ -4210,6 +4604,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Gets dependency referenced exports.
 	 * @param {Dependency} dependency the dependency
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @returns {ReferencedExports} referenced exports
@@ -4227,6 +4622,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Removes reasons of dependency block.
 	 * @param {Module} module module relationship for removal
 	 * @param {DependenciesBlockLike} block dependencies block
 	 * @returns {void}
@@ -4257,6 +4653,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Patch chunks after reason removal.
 	 * @param {Module} module module to patch tie
 	 * @param {Chunk} chunk chunk to patch tie
 	 * @returns {void}
@@ -4275,12 +4672,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Removes chunk from dependencies.
 	 * @param {DependenciesBlock} block block tie for Chunk
 	 * @param {Chunk} chunk chunk to remove from dep
 	 * @returns {void}
 	 */
 	removeChunkFromDependencies(block, chunk) {
 		/**
+		 * Iterator dependency.
 		 * @param {Dependency} d dependency to (maybe) patch up
 		 */
 		const iteratorDependency = (d) => {
@@ -4314,6 +4713,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	assignRuntimeIds() {
 		const { chunkGraph } = this;
 		/**
+		 * Process entrypoint.
 		 * @param {Entrypoint} ep an entrypoint
 		 */
 		const processEntrypoint = (ep) => {
@@ -4367,10 +4767,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		for (const module of this.modules) {
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+				const cacheKey = memCache
+					? `moduleHash-${getRuntimeKey(runtime)}`
+					: undefined;
 				if (memCache) {
 					const digest =
 						/** @type {string} */
-						(memCache.get(`moduleHash-${getRuntimeKey(runtime)}`));
+						(memCache.get(/** @type {string} */ (cacheKey)));
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,
@@ -4394,7 +4797,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					errors
 				);
 				if (memCache) {
-					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+					memCache.set(/** @type {string} */ (cacheKey), digest);
 				}
 			}
 		}
@@ -4416,6 +4819,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * Create module hash.
 	 * @private
 	 * @param {Module} module module
 	 * @param {ChunkGraph} chunkGraph the chunk graph
@@ -4630,6 +5034,7 @@ This prevents using hashes of each other and should be avoided.`);
 		const errors = [];
 
 		/**
+		 * Processes the provided chunk.
 		 * @param {Chunk} chunk chunk
 		 */
 		const processChunk = (chunk) => {
@@ -4762,12 +5167,18 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Processes the provided file.
 	 * @param {string} file file name
 	 * @param {Source} source asset source
 	 * @param {AssetInfo} assetInfo extra asset information
 	 * @returns {void}
 	 */
 	emitAsset(file, source, assetInfo = {}) {
+		// A file may be attached to a chunk right after any emit (including the
+		// re-emit path for assets shared across chunks in createChunkAssets), so
+		// the lazily-built reverse index is stale after every emitAsset.
+		this._assetToChunkIndex = undefined;
+		this._assetToChunkAuxiliaryIndex = undefined;
 		if (this.assets[file]) {
 			if (!isSourceEqual(this.assets[file], source)) {
 				this.errors.push(
@@ -4793,6 +5204,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Processes the provided file.
 	 * @private
 	 * @param {string} file file name
 	 * @param {AssetInfo=} newInfo new asset information
@@ -4809,6 +5221,7 @@ This prevents using hashes of each other and should be avoided.`);
 		if (oldRelated) {
 			for (const key of Object.keys(oldRelated)) {
 				/**
+				 * Processes the provided name.
 				 * @param {string} name name
 				 */
 				const remove = (name) => {
@@ -4834,6 +5247,7 @@ This prevents using hashes of each other and should be avoided.`);
 		if (newRelated) {
 			for (const key of Object.keys(newRelated)) {
 				/**
+				 * Processes the provided name.
 				 * @param {string} name name
 				 */
 				const add = (name) => {
@@ -4860,6 +5274,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Updates asset using the provided file.
 	 * @param {string} file file name
 	 * @param {Source | ((source: Source) => Source)} newSourceOrFunction new asset source or function converting old to new
 	 * @param {(AssetInfo | ((assetInfo?: AssetInfo) => AssetInfo | undefined)) | undefined} assetInfoUpdateOrFunction new asset info or function converting old to new
@@ -4893,6 +5308,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Processes the provided file.
 	 * @param {string} file file name
 	 * @param {string} newFile the new name of file
 	 */
@@ -4944,25 +5360,99 @@ This prevents using hashes of each other and should be avoided.`);
 		this._setAssetInfo(newFile, assetInfo);
 		delete this.assets[file];
 		this.assets[newFile] = source;
+		this._buildAssetToChunkIndex();
+		const index = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkIndex
+		);
+		const auxiliaryIndex = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkAuxiliaryIndex
+		);
+		const chunks = index.get(file);
+		const auxiliaryChunks = auxiliaryIndex.get(file);
+		if (chunks === undefined && auxiliaryChunks === undefined) {
+			// Not tracked in either index: chunk sets may have been mutated
+			// directly (bypassing emitAsset), so scan all chunks to stay correct.
+			for (const chunk of this.chunks) {
+				this._renameAssetInChunk(chunk, chunk.files, index, file, newFile);
+				this._renameAssetInChunk(
+					chunk,
+					chunk.auxiliaryFiles,
+					auxiliaryIndex,
+					file,
+					newFile
+				);
+			}
+			return;
+		}
+		if (chunks !== undefined) {
+			index.delete(file);
+			for (const chunk of chunks) {
+				this._renameAssetInChunk(chunk, chunk.files, index, file, newFile);
+			}
+		}
+		if (auxiliaryChunks !== undefined) {
+			auxiliaryIndex.delete(file);
+			for (const chunk of auxiliaryChunks) {
+				this._renameAssetInChunk(
+					chunk,
+					chunk.auxiliaryFiles,
+					auxiliaryIndex,
+					file,
+					newFile
+				);
+			}
+		}
+	}
+
+	// Lazily build the reverse index file -> chunks. emitAsset() invalidates
+	// it, so chunk.files / chunk.auxiliaryFiles entries added alongside a newly
+	// emitted asset are always picked up on the next rebuild.
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_buildAssetToChunkIndex() {
+		if (this._assetToChunkIndex !== undefined) return;
+		/** @type {Map<string, Set<Chunk>>} */
+		const filesIndex = new Map();
+		/** @type {Map<string, Set<Chunk>>} */
+		const auxiliaryIndex = new Map();
 		for (const chunk of this.chunks) {
-			{
-				const size = chunk.files.size;
-				chunk.files.delete(file);
-				if (size !== chunk.files.size) {
-					chunk.files.add(newFile);
-				}
+			for (const file of chunk.files) {
+				let set = filesIndex.get(file);
+				if (set === undefined) filesIndex.set(file, (set = new Set()));
+				set.add(chunk);
 			}
-			{
-				const size = chunk.auxiliaryFiles.size;
-				chunk.auxiliaryFiles.delete(file);
-				if (size !== chunk.auxiliaryFiles.size) {
-					chunk.auxiliaryFiles.add(newFile);
-				}
+			for (const file of chunk.auxiliaryFiles) {
+				let set = auxiliaryIndex.get(file);
+				if (set === undefined) auxiliaryIndex.set(file, (set = new Set()));
+				set.add(chunk);
 			}
 		}
+		this._assetToChunkIndex = filesIndex;
+		this._assetToChunkAuxiliaryIndex = auxiliaryIndex;
+	}
+
+	/**
+	 * @private
+	 * @param {Chunk} chunk the chunk owning the set
+	 * @param {Set<string>} set chunk.files or chunk.auxiliaryFiles
+	 * @param {Map<string, Set<Chunk>>} index matching reverse index
+	 * @param {string} file old file name
+	 * @param {string} newFile new file name
+	 * @returns {void}
+	 */
+	_renameAssetInChunk(chunk, set, index, file, newFile) {
+		// Only carry the rename to chunks that actually held the old name.
+		if (!set.delete(file)) return;
+		set.add(newFile);
+		let target = index.get(newFile);
+		if (target === undefined) index.set(newFile, (target = new Set()));
+		target.add(chunk);
 	}
 
 	/**
+	 * Processes the provided file.
 	 * @param {string} file file name
 	 */
 	deleteAsset(file) {
@@ -4976,6 +5466,7 @@ This prevents using hashes of each other and should be avoided.`);
 		if (related) {
 			for (const key of Object.keys(related)) {
 				/**
+				 * Checks used and delete.
 				 * @param {string} file file
 				 */
 				const checkUsedAndDelete = (file) => {
@@ -4993,11 +5484,31 @@ This prevents using hashes of each other and should be avoided.`);
 				}
 			}
 		}
-		// TODO If this becomes a performance problem
-		// store a reverse mapping from asset to chunk
-		for (const chunk of this.chunks) {
-			chunk.files.delete(file);
-			chunk.auxiliaryFiles.delete(file);
+		this._buildAssetToChunkIndex();
+		const index = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkIndex
+		);
+		const auxiliaryIndex = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkAuxiliaryIndex
+		);
+		const chunks = index.get(file);
+		const auxiliaryChunks = auxiliaryIndex.get(file);
+		if (chunks === undefined && auxiliaryChunks === undefined) {
+			// Not tracked in either index: chunk sets may have been mutated
+			// directly (bypassing emitAsset), so scan all chunks to stay correct.
+			for (const chunk of this.chunks) {
+				chunk.files.delete(file);
+				chunk.auxiliaryFiles.delete(file);
+			}
+			return;
+		}
+		if (chunks !== undefined) {
+			for (const chunk of chunks) chunk.files.delete(file);
+			index.delete(file);
+		}
+		if (auxiliaryChunks !== undefined) {
+			for (const chunk of auxiliaryChunks) chunk.auxiliaryFiles.delete(file);
+			auxiliaryIndex.delete(file);
 		}
 	}
 
@@ -5017,6 +5528,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Returns the asset or undefined when not found.
 	 * @param {string} name the name of the asset
 	 * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
 	 */
@@ -5034,6 +5546,8 @@ This prevents using hashes of each other and should be avoided.`);
 			chunk.files.clear();
 			chunk.auxiliaryFiles.clear();
 		}
+		this._assetToChunkIndex = undefined;
+		this._assetToChunkAuxiliaryIndex = undefined;
 	}
 
 	createModuleAssets() {
@@ -5062,6 +5576,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Gets render manifest.
 	 * @param {RenderManifestOptions} options options object
 	 * @returns {RenderManifestEntry[]} manifest entries
 	 */
@@ -5070,6 +5585,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Creates a chunk assets.
 	 * @param {Callback} callback signals when the call finishes
 	 * @returns {void}
 	 */
@@ -5119,7 +5635,7 @@ This prevents using hashes of each other and should be avoided.`);
 						);
 
 						assetCacheItem.get((err, sourceFromCache) => {
-							/** @type {TemplatePath} */
+							/** @type {string | import("./TemplatedPathPlugin").TemplatePathFn<EXPECTED_ANY>} */
 							let filenameTemplate;
 							/** @type {string} */
 							let file;
@@ -5128,6 +5644,7 @@ This prevents using hashes of each other and should be avoided.`);
 
 							let inTry = true;
 							/**
+							 * Error and callback.
 							 * @param {Error} err error
 							 * @returns {void}
 							 */
@@ -5235,11 +5752,13 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {TemplatePath} filename used to get asset path with hash
-	 * @param {PathData} data context data
+	 * Returns interpolated path.
+	 * @template {PathData} [T=PathData]
+	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {T=} data context data
 	 * @returns {string} interpolated path
 	 */
-	getPath(filename, data = {}) {
+	getPath(filename, data = /** @type {T} */ ({})) {
 		if (!data.hash) {
 			data = {
 				hash: this.hash,
@@ -5250,11 +5769,13 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {TemplatePath} filename used to get asset path with hash
-	 * @param {PathData} data context data
+	 * Gets path with info.
+	 * @template {PathData} [T=PathData]
+	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {T=} data context data
 	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
-	getPathWithInfo(filename, data = {}) {
+	getPathWithInfo(filename, data = /** @type {T} */ ({})) {
 		if (!data.hash) {
 			data = {
 				hash: this.hash,
@@ -5265,8 +5786,10 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {TemplatePath} filename used to get asset path with hash
-	 * @param {PathData} data context data
+	 * Returns interpolated path.
+	 * @template {PathData} [T=PathData]
+	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {T} data context data
 	 * @returns {string} interpolated path
 	 */
 	getAssetPath(filename, data) {
@@ -5278,8 +5801,10 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {TemplatePath} filename used to get asset path with hash
-	 * @param {PathData} data context data
+	 * Gets asset path with info.
+	 * @template {PathData} [T=PathData]
+	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {T} data context data
 	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
 	getAssetPathWithInfo(filename, data) {
@@ -5323,6 +5848,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
+	 * Processes the provided module.
 	 * @param {Module} module the module
 	 * @param {ExecuteModuleOptions} options options
 	 * @param {ExecuteModuleCallback} callback callback
@@ -5373,7 +5899,9 @@ This prevents using hashes of each other and should be avoided.`);
 					...options.entryOptions
 				});
 				chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
-				connectChunkGroupAndChunk(entrypoint, chunk);
+				if (entrypoint.pushChunk(chunk)) {
+					chunk.addGroup(entrypoint);
+				}
 				entrypoint.setRuntimeChunk(chunk);
 				entrypoint.setEntrypointChunk(chunk);
 
@@ -5407,6 +5935,7 @@ This prevents using hashes of each other and should be avoided.`);
 					this.outputOptions.hashFunction
 				);
 				/**
+				 * Processes the provided module.
 				 * @param {Module} module the module
 				 * @param {Callback} callback callback
 				 * @returns {void}
@@ -5512,6 +6041,8 @@ This prevents using hashes of each other and should be avoided.`);
 								const assets = new Map();
 
 								let cacheable = true;
+								/** @type {ExecuteModuleResult["notCacheableReasons"]} */
+								const notCacheableReasons = [];
 
 								/** @type {ExecuteModuleContext} */
 								const context = {
@@ -5547,11 +6078,18 @@ This prevents using hashes of each other and should be avoided.`);
 											missingDependencies,
 											buildDependencies
 										);
-										if (
-											/** @type {BuildInfo} */ (module.buildInfo).cacheable ===
-											false
-										) {
+										const buildInfo = /** @type {BuildInfo} */ (
+											module.buildInfo
+										);
+										if (buildInfo.cacheable === false) {
 											cacheable = false;
+											if (buildInfo.notCacheableReasons) {
+												for (const reason of buildInfo.notCacheableReasons) {
+													if (!notCacheableReasons.includes(reason)) {
+														notCacheableReasons.push(reason);
+													}
+												}
+											}
 										}
 										if (module.buildInfo && module.buildInfo.assets) {
 											const { assets: moduleAssets, assetsInfo } =
@@ -5617,6 +6155,7 @@ This prevents using hashes of each other and should be avoided.`);
 											context.__webpack_require__ = __webpack_require__;
 
 											/**
+											 * Webpack require module.
 											 * @param {ExecuteModuleArgument} moduleArgument the module argument
 											 * @param {string=} id id
 											 * @returns {ExecuteModuleExports} exports
@@ -5702,6 +6241,7 @@ This prevents using hashes of each other and should be avoided.`);
 											exports,
 											assets,
 											cacheable,
+											notCacheableReasons,
 											fileDependencies,
 											contextDependencies,
 											missingDependencies,
@@ -5759,6 +6299,7 @@ This prevents using hashes of each other and should be avoided.`);
 }
 
 /**
+ * Defines the factorize module options type used by this module.
  * @typedef {object} FactorizeModuleOptions
  * @property {ModuleProfile=} currentProfile
  * @property {ModuleFactory} factory
@@ -5770,6 +6311,7 @@ This prevents using hashes of each other and should be avoided.`);
  */
 
 /**
+ * Processes the provided factorize module option.
  * @param {FactorizeModuleOptions} options options object
  * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
  * @returns {void}
@@ -5796,6 +6338,7 @@ Object.defineProperty(compilationPrototype, "cache", {
 	configurable: false,
 	get: util.deprecate(
 		/**
+		 * Returns the cache.
 		 * @this {Compilation} the compilation
 		 * @returns {Cache} the cache
 		 */
@@ -5807,6 +6350,7 @@ Object.defineProperty(compilationPrototype, "cache", {
 	),
 	set: util.deprecate(
 		/**
+		 * Handles the value callback for this hook.
 		 * @param {EXPECTED_ANY} _v value
 		 */
 		(_v) => {},