webpack 5.107.1 → 5.107.2

package/lib/Compiler.js

@@ -491,6 +491,25 @@ class Compiler {
 		}
 	}
 
+	/**
+	 * Release fields on a finished compilation that nothing reads after emit,
+	 * so the heap can shrink while user code still holds the Stats reference.
+	 * Recurses into child compilations. Stats output is preserved — only
+	 * codeGen byproducts are dropped.
+	 * @param {Compilation} compilation finished compilation to slim down
+	 * @returns {void}
+	 */
+	_releaseUnusedCompilationData(compilation) {
+		for (const child of compilation.children) {
+			this._releaseUnusedCompilationData(child);
+		}
+		// Rendered source per (module × runtime) — used only during seal/emit,
+		// never read by Stats, and not serialized to the persistent cache.
+		if (compilation.codeGenerationResults !== undefined) {
+			compilation.codeGenerationResults.map.clear();
+		}
+	}
+
 	/**
 	 * Returns a compiler watcher.
 	 * @param {WatchOptions} watchOptions the watcher's options
@@ -1439,9 +1458,14 @@ ${other}`);
 		}
 		this.hooks.shutdown.callAsync((err) => {
 			if (err) return callback(err);
-			// Get rid of reference to last compilation to avoid leaking memory
-			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
-			// might be still in use. We try to get rid of the reference to the cache instead.
+			// Defer a microtask so a close() made inside the run callback can't
+			// release codeGenerationResults before afterDone fires on the same stack.
+			const lastCompilation = this._lastCompilation;
+			if (lastCompilation !== undefined) {
+				Promise.resolve().then(() => {
+					this._releaseUnusedCompilationData(lastCompilation);
+				});
+			}
 			this._lastCompilation = undefined;
 			this._lastNormalModuleFactory = undefined;
 			this.cache.shutdown(callback);

package/lib/ContextModuleFactory.js

@@ -379,6 +379,8 @@ class ContextModuleFactory extends ModuleFactory {
 				if (!processedFiles || processedFiles.length === 0) {
 					return callback(null, []);
 				}
+				/** @type {ContextAlternativeRequest[]} */
+				const fileObjs = [];
 				asyncLib.map(
 					processedFiles.filter((p) => p.indexOf(".") !== 0),
 					(segment, callback) => {
@@ -404,41 +406,16 @@ class ContextModuleFactory extends ModuleFactory {
 									stat.isFile() &&
 									(!include || include.test(subResource))
 								) {
-									/** @type {{ context: string, request: string }} */
-									const obj = {
+									// Collect for a single batched alternativeRequests call
+									// per directory below. Calling the hook once per file
+									// would pay per-call overhead (closure, resolverFactory
+									// lookup, array allocations) for every file in the
+									// context — which is the bulk of work on rebuilds.
+									fileObjs.push({
 										context: ctx,
 										request: `.${subResource.slice(ctx.length).replace(/\\/g, "/")}`
-									};
-
-									this.hooks.alternativeRequests.callAsync(
-										[obj],
-										options,
-										(err, alternatives) => {
-											if (err) return callback(err);
-											callback(
-												null,
-												/** @type {ContextAlternativeRequest[]} */
-												(alternatives)
-													.filter((obj) =>
-														regExp.test(/** @type {string} */ (obj.request))
-													)
-													.map((obj) => {
-														const dep = new ContextElementDependency(
-															`${obj.request}${resourceQuery}${resourceFragment}`,
-															obj.request,
-															typePrefix,
-															/** @type {string} */
-															(category),
-															referencedExports,
-															obj.context,
-															attributes
-														);
-														dep.optional = true;
-														return dep;
-													})
-											);
-										}
-									);
+									});
+									callback();
 								} else {
 									callback();
 								}
@@ -450,16 +427,46 @@ class ContextModuleFactory extends ModuleFactory {
 					(err, result) => {
 						if (err) return callback(err);
 
-						if (!result) return callback(null, []);
-
 						/** @type {ContextElementDependency[]} */
 						const flattenedResult = [];
 
-						for (const item of result) {
-							if (item) flattenedResult.push(...item);
+						if (result) {
+							for (const item of result) {
+								if (item) flattenedResult.push(...item);
+							}
 						}
 
-						callback(null, flattenedResult);
+						if (fileObjs.length === 0) {
+							return callback(null, flattenedResult);
+						}
+
+						this.hooks.alternativeRequests.callAsync(
+							fileObjs,
+							options,
+							(err, alternatives) => {
+								if (err) return callback(err);
+								for (const alt of /** @type {ContextAlternativeRequest[]} */ (
+									alternatives
+								)) {
+									if (!regExp.test(/** @type {string} */ (alt.request))) {
+										continue;
+									}
+									const dep = new ContextElementDependency(
+										`${alt.request}${resourceQuery}${resourceFragment}`,
+										alt.request,
+										typePrefix,
+										/** @type {string} */
+										(category),
+										referencedExports,
+										alt.context,
+										attributes
+									);
+									dep.optional = true;
+									flattenedResult.push(dep);
+								}
+								callback(null, flattenedResult);
+							}
+						);
 					}
 				);
 			});

package/lib/MultiCompiler.js

@@ -128,6 +128,20 @@ module.exports = class MultiCompiler {
 					doneCompilers--;
 				}
 			});
+			// Release fields on this child's Compilation once it's done. The
+			// stage: Infinity tap runs after every afterDone tap at a lower
+			// stage, so plugins observing compilation state in afterDone still
+			// see it intact. Stats remains usable; only fields Stats never reads
+			// (and that the persistent cache never serializes) are dropped.
+
+			compiler.hooks.afterDone.tap(
+				{ name: CLASS_NAME, stage: Infinity },
+				(stats) => {
+					if (stats !== undefined) {
+						compiler._releaseUnusedCompilationData(stats.compilation);
+					}
+				}
+			);
 		}
 		this._validateCompilersOptions();
 	}