webpack 5.99.5 → 5.99.7

package/lib/serialization/SingleItemMiddleware.js

@@ -6,13 +6,12 @@
 
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("./SerializerMiddleware").Context} Context */
-
-/** @typedef {any} DeserializedType */
-/** @typedef {any[]} SerializedType */
+/** @typedef {EXPECTED_ANY} DeserializedType */
+/** @typedef {EXPECTED_ANY[]} SerializedType */
+/** @typedef {{}} Context */
 
 /**
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class SingleItemMiddleware extends SerializerMiddleware {
 	/**

package/lib/sharing/ProvideSharedPlugin.js

@@ -36,6 +36,8 @@ const validate = createSchemaValidation(
 
 /** @typedef {Map<string, { config: ProvideOptions, version: string | undefined | false }>} ResolvedProvideMap */
 
+const PLUGIN_NAME = "ProvideSharedPlugin";
+
 class ProvideSharedPlugin {
 	/**
 	 * @param {ProvideSharedPluginOptions} options options
@@ -83,7 +85,7 @@ class ProvideSharedPlugin {
 		const compilationData = new WeakMap();
 
 		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				/** @type {ResolvedProvideMap} */
 				const resolvedProvideMap = new Map();
@@ -156,7 +158,7 @@ class ProvideSharedPlugin {
 					});
 				};
 				normalModuleFactory.hooks.module.tap(
-					"ProvideSharedPlugin",
+					PLUGIN_NAME,
 					(module, { resource, resourceResolveData }, resolveData) => {
 						if (resolvedProvideMap.has(/** @type {string} */ (resource))) {
 							return module;
@@ -194,7 +196,7 @@ class ProvideSharedPlugin {
 				);
 			}
 		);
-		compiler.hooks.finishMake.tapPromise("ProvideSharedPlugin", compilation => {
+		compiler.hooks.finishMake.tapPromise(PLUGIN_NAME, compilation => {
 			const resolvedProvideMap = compilationData.get(compilation);
 			if (!resolvedProvideMap) return Promise.resolve();
 			return Promise.all(
@@ -225,7 +227,7 @@ class ProvideSharedPlugin {
 		});
 
 		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					ProvideForSharedDependency,

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -27,12 +27,14 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
+/** @typedef {import("../Chunk").ChunkName} ChunkName */
 /** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").Asset} Asset */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").ExcludeModulesType} ExcludeModulesType */
 /** @typedef {import("../Compilation").KnownNormalizedStatsOptions} KnownNormalizedStatsOptions */
 /** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -62,7 +64,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {KnownStatsCompilation & Record<string, EXPECTED_ANY>} StatsCompilation */
 /**
  * @typedef {object} KnownStatsCompilation
- * @property {any=} env
+ * @property {Record<string, EXPECTED_ANY>=} env
  * @property {string=} name
  * @property {string=} hash
  * @property {string=} version
@@ -85,6 +87,8 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number=} warningsCount
  * @property {StatsCompilation[]=} children
  * @property {Record<string, StatsLogging>=} logging
+ * @property {number=} filteredWarningDetailsCount
+ * @property {number=} filteredErrorDetailsCount
  */
 
 /** @typedef {KnownStatsLogging & Record<string, EXPECTED_ANY>} StatsLogging */
@@ -107,6 +111,9 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  */
 
 /** @typedef {KnownStatsAsset & Record<string, EXPECTED_ANY>} StatsAsset */
+/** @typedef {ChunkId} KnownStatsAssetChunk */
+/** @typedef {ChunkName} KnownStatsAssetChunkName */
+/** @typedef {string} KnownStatsAssetChunkIdHint */
 /**
  * @typedef {object} KnownStatsAsset
  * @property {string} type
@@ -117,12 +124,12 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean} comparedForEmit
  * @property {boolean} cached
  * @property {StatsAsset[]=} related
- * @property {(string|number)[]=} chunkNames
- * @property {(string|number)[]=} chunkIdHints
- * @property {(string|number)[]=} chunks
- * @property {(string|number)[]=} auxiliaryChunkNames
- * @property {(string|number)[]=} auxiliaryChunks
- * @property {(string|number)[]=} auxiliaryChunkIdHints
+ * @property {KnownStatsAssetChunk[]=} chunks
+ * @property {KnownStatsAssetChunkName[]=} chunkNames
+ * @property {KnownStatsAssetChunkIdHint[]=} chunkIdHints
+ * @property {KnownStatsAssetChunk[]=} auxiliaryChunks
+ * @property {KnownStatsAssetChunkName[]=} auxiliaryChunkNames
+ * @property {KnownStatsAssetChunkIdHint[]=} auxiliaryChunkIdHints
  * @property {number=} filteredRelated
  * @property {boolean=} isOverSizeLimit
  */
@@ -143,6 +150,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} isOverSizeLimit
  */
 
+/** @typedef {Module[]} ModuleIssuerPath */
 /** @typedef {KnownStatsModule & Record<string, EXPECTED_ANY>} StatsModule */
 /**
  * @typedef {object} KnownStatsModule
@@ -172,7 +180,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} dependent
  * @property {(string | null)=} issuer
  * @property {(string | null)=} issuerName
- * @property {StatsModuleIssuer[]=} issuerPath
+ * @property {StatsModuleIssuer[] | null=} issuerPath
  * @property {boolean=} failed
  * @property {number=} errors
  * @property {number=} warnings
@@ -244,7 +252,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {string[]} files
  * @property {string[]} auxiliaryFiles
  * @property {string} hash
- * @property {Record<string, (string|number)[]>} childrenByOrder
+ * @property {Record<string, ChunkId[]>} childrenByOrder
  * @property {(string|number)=} id
  * @property {(string|number)[]=} siblings
  * @property {(string|number)[]=} parents
@@ -299,6 +307,8 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {StatsModuleTraceItem[]=} moduleTrace
  * @property {string=} details
  * @property {string=} stack
+ * @property {KnownStatsError=} cause
+ * @property {KnownStatsError[]=} errors
  * @property {string=} compilerPath
  */
 
@@ -310,12 +320,15 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @typedef {Record<string, (object: O, data: T, context: StatsFactoryContext, options: NormalizedStatsOptions, factory: StatsFactory) => void>} ExtractorsByOption
  */
 
+/** @typedef {{ name: string, chunkGroup: ChunkGroup }} ChunkGroupInfoWithName */
+/** @typedef {{ origin: Module, module: Module }} ModuleTrace */
+
 /**
  * @typedef {object} SimpleExtractors
  * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
- * @property {ExtractorsByOption<{ name: string, chunkGroup: ChunkGroup }, StatsChunkGroup>} chunkGroup
+ * @property {ExtractorsByOption<ChunkGroupInfoWithName, StatsChunkGroup>} chunkGroup
  * @property {ExtractorsByOption<Module, StatsModule>} module
  * @property {ExtractorsByOption<Module, StatsModule>} module$visible
  * @property {ExtractorsByOption<Module, StatsModuleIssuer>} moduleIssuer
@@ -325,7 +338,8 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {ExtractorsByOption<OriginRecord, StatsChunkOrigin>} chunkOrigin
  * @property {ExtractorsByOption<WebpackError, StatsError>} error
  * @property {ExtractorsByOption<WebpackError, StatsError>} warning
- * @property {ExtractorsByOption<{ origin: Module, module: Module }, StatsModuleTraceItem>} moduleTraceItem
+ * @property {ExtractorsByOption<WebpackError, StatsError>} cause
+ * @property {ExtractorsByOption<ModuleTrace, StatsModuleTraceItem>} moduleTraceItem
  * @property {ExtractorsByOption<Dependency, StatsModuleTraceDependency>} moduleTraceDependency
  */
 
@@ -394,55 +408,75 @@ const countWithChildren = (compilation, getItems) => {
 	return count;
 };
 
-/** @type {ExtractorsByOption<WebpackError | string, StatsError>} */
+/** @typedef {Error & { cause?: unknown }} ErrorWithCause */
+/** @typedef {Error & { errors: EXPECTED_ANY[] }} AggregateError */
+
+/** @type {ExtractorsByOption<string | ErrorWithCause | AggregateError | WebpackError, StatsError>} */
 const EXTRACT_ERROR = {
 	_: (object, error, context, { requestShortener }) => {
 		// TODO webpack 6 disallow strings in the errors/warnings list
 		if (typeof error === "string") {
 			object.message = error;
 		} else {
-			if (error.chunk) {
+			if (/** @type {WebpackError} */ (error).chunk) {
+				const chunk = /** @type {WebpackError} */ (error).chunk;
 				object.chunkName =
 					/** @type {string | undefined} */
-					(error.chunk.name);
-				object.chunkEntry = error.chunk.hasRuntime();
-				object.chunkInitial = error.chunk.canBeInitial();
+					(chunk.name);
+				object.chunkEntry = chunk.hasRuntime();
+				object.chunkInitial = chunk.canBeInitial();
 			}
-			if (error.file) {
-				object.file = error.file;
+
+			if (/** @type {WebpackError} */ (error).file) {
+				object.file = /** @type {WebpackError} */ (error).file;
 			}
-			if (error.module) {
-				object.moduleIdentifier = error.module.identifier();
-				object.moduleName = error.module.readableIdentifier(requestShortener);
+
+			if (/** @type {WebpackError} */ (error).module) {
+				object.moduleIdentifier =
+					/** @type {WebpackError} */
+					(error).module.identifier();
+				object.moduleName =
+					/** @type {WebpackError} */
+					(error).module.readableIdentifier(requestShortener);
 			}
-			if (error.loc) {
-				object.loc = formatLocation(error.loc);
+
+			if (/** @type {WebpackError} */ (error).loc) {
+				object.loc = formatLocation(/** @type {WebpackError} */ (error).loc);
 			}
+
 			object.message = error.message;
 		}
 	},
 	ids: (object, error, { compilation: { chunkGraph } }) => {
 		if (typeof error !== "string") {
-			if (error.chunk) {
-				object.chunkId = /** @type {ChunkId} */ (error.chunk.id);
+			if (/** @type {WebpackError} */ (error).chunk) {
+				object.chunkId = /** @type {ChunkId} */ (
+					/** @type {WebpackError} */
+					(error).chunk.id
+				);
 			}
-			if (error.module) {
+
+			if (/** @type {WebpackError} */ (error).module) {
 				object.moduleId =
 					/** @type {ModuleId} */
-					(chunkGraph.getModuleId(error.module));
+					(chunkGraph.getModuleId(/** @type {WebpackError} */ (error).module));
 			}
 		}
 	},
 	moduleTrace: (object, error, context, options, factory) => {
-		if (typeof error !== "string" && error.module) {
+		if (
+			typeof error !== "string" &&
+			/** @type {WebpackError} */ (error).module
+		) {
 			const {
 				type,
 				compilation: { moduleGraph }
 			} = context;
 			/** @type {Set<Module>} */
 			const visitedModules = new Set();
+			/** @type {ModuleTrace[]} */
 			const moduleTrace = [];
-			let current = error.module;
+			let current = /** @type {WebpackError} */ (error).module;
 			while (current) {
 				if (visitedModules.has(current)) break; // circular (technically impossible, but how knows)
 				visitedModules.add(current);
@@ -469,13 +503,44 @@ const EXTRACT_ERROR = {
 			(errorDetails === true ||
 				(type.endsWith(".error") && cachedGetErrors(compilation).length < 3))
 		) {
-			object.details = error.details;
+			object.details = /** @type {WebpackError} */ (error).details;
 		}
 	},
 	errorStack: (object, error) => {
 		if (typeof error !== "string") {
 			object.stack = error.stack;
 		}
+	},
+	errorCause: (object, error, context, options, factory) => {
+		if (
+			typeof error !== "string" &&
+			/** @type {ErrorWithCause} */ (error).cause
+		) {
+			const rawCause = /** @type {ErrorWithCause} */ (error).cause;
+			/** @type {Error} */
+			const cause =
+				typeof rawCause === "string"
+					? /** @type {Error} */ ({ message: rawCause })
+					: /** @type {Error} */ (rawCause);
+			const { type } = context;
+
+			object.cause = factory.create(`${type}.cause`, cause, context);
+		}
+	},
+	errorErrors: (object, error, context, options, factory) => {
+		if (
+			typeof error !== "string" &&
+			/** @type {AggregateError} */
+			(error).errors
+		) {
+			const { type } = context;
+			object.errors = factory.create(
+				`${type}.errors`,
+				/** @type {Error[]} */
+				(/** @type {AggregateError} */ (error).errors),
+				context
+			);
+		}
 	}
 };
 
@@ -796,6 +861,7 @@ const SIMPLE_EXTRACTORS = {
 			factory
 		) => {
 			const { type } = context;
+			/** @type {ChunkGroupInfoWithName[]} */
 			const array = Array.from(compilation.entrypoints, ([key, value]) => ({
 				name: key,
 				chunkGroup: value
@@ -915,12 +981,13 @@ const SIMPLE_EXTRACTORS = {
 					/** @type {KnownNormalizedStatsOptions["warningsFilter"]} */
 					(warningsFilter).length === 0
 				)
-					return cachedGetWarnings(c);
+					// Type is wrong, because we don't need the real value for counting
+					return /** @type {EXPECTED_ANY[]} */ (cachedGetWarnings(c));
 				return factory
 					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
 					.filter(
 						/**
-						 * @param {TODO} warning warning
+						 * @param {StatsError} warning warning
 						 * @returns {boolean} result
 						 */
 						warning => {
@@ -1169,7 +1236,6 @@ const SIMPLE_EXTRACTORS = {
 				cached: !built && !codeGenerated
 			};
 			Object.assign(object, statsModule);
-
 			if (built || codeGenerated || options.cachedModules) {
 				Object.assign(
 					object,
@@ -1183,7 +1249,7 @@ const SIMPLE_EXTRACTORS = {
 			const { type, rootModules } = context;
 			const compilation = /** @type {Compilation} */ (context.compilation);
 			const { moduleGraph } = compilation;
-			/** @type {Module[]} */
+			/** @type {ModuleIssuerPath} */
 			const path = [];
 			const issuer = moduleGraph.getIssuer(module);
 			let current = issuer;
@@ -1221,7 +1287,8 @@ const SIMPLE_EXTRACTORS = {
 				issuerName: issuer && issuer.readableIdentifier(requestShortener),
 				issuerPath:
 					issuer &&
-					factory.create(`${type.slice(0, -8)}.issuerPath`, path, context),
+					/** @type {StatsModuleIssuer[] | undefined} */
+					(factory.create(`${type.slice(0, -8)}.issuerPath`, path, context)),
 				failed: errorsCount > 0,
 				errors: errorsCount,
 				warnings: warningsCount
@@ -1506,6 +1573,7 @@ const SIMPLE_EXTRACTORS = {
 			} = context;
 			/** @type {Set<string>} */
 			const originsKeySet = new Set();
+			/** @type {OriginRecord[]} */
 			const origins = [];
 			for (const g of chunk.groupsIterable) {
 				origins.push(...g.origins);
@@ -1545,6 +1613,7 @@ const SIMPLE_EXTRACTORS = {
 	},
 	error: EXTRACT_ERROR,
 	warning: EXTRACT_ERROR,
+	cause: EXTRACT_ERROR,
 	moduleTraceItem: {
 		_: (object, { origin, module }, context, { requestShortener }, factory) => {
 			const {
@@ -1562,7 +1631,8 @@ const SIMPLE_EXTRACTORS = {
 				.map(c => c.dependency);
 			object.dependencies = factory.create(
 				`${type}.dependencies`,
-				Array.from(new Set(dependencies)),
+				/** @type {Dependency[]} */
+				(Array.from(new Set(dependencies))),
 				context
 			);
 		},
@@ -1612,9 +1682,7 @@ const FILTER_RESULTS = {
 	}
 };
 
-/**
- * @type {Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext) => void>}
- */
+/** @type {Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext) => void>} */
 const MODULES_SORTER = {
 	_: (comparators, { compilation: { moduleGraph } }) => {
 		comparators.push(
@@ -1625,7 +1693,7 @@ const MODULES_SORTER = {
 	}
 };
 
-/** @type {Record<string, Record<string, (comparators: Comparator<any>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+/** @type {Record<string, Record<string, (comparators: Comparator<TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
 const SORTERS = {
 	"compilation.chunks": {
 		_: comparators => {
@@ -1679,7 +1747,7 @@ const SORTERS = {
 
 /**
  * @template T
- * @typedef {T & { children: Children<T>[] | undefined, filteredChildren?: number }} Children
+ * @typedef {T & { children?: Children<T>[] | undefined, filteredChildren?: number }} Children
  */
 
 /**
@@ -2051,6 +2119,7 @@ const ASSETS_GROUPERS = {
 					const pathMatch =
 						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+					/** @type {string[]} */
 					const keys = [];
 					if (groupAssetsByPath) {
 						keys.push(".");
@@ -2141,7 +2210,7 @@ const ASSETS_GROUPERS = {
 
 /** @typedef {Record<string, (groupConfigs: GroupConfig<KnownStatsModule, TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} ModulesGroupers */
 
-/** @type {(type: "module" | "chunk" | "root-of-chunk" | "nested") => ModulesGroupers} */
+/** @type {(type: ExcludeModulesType) => ModulesGroupers} */
 const MODULES_GROUPERS = type => ({
 	_: (groupConfigs, context, options) => {
 		/**
@@ -2386,7 +2455,7 @@ const sortByField = field => {
 	return sortFn;
 };
 
-/** @type {Record<string, (comparators: Comparator<TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+/** @type {Record<string, (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
 const ASSET_SORTERS = {
 	assetsSort: (comparators, context, { assetsSort }) => {
 		comparators.push(sortByField(assetsSort));
@@ -2459,6 +2528,8 @@ const ITEM_NAMES = {
 	"compilation.namedChunkGroups[]": "chunkGroup",
 	"compilation.errors[]": "error",
 	"compilation.warnings[]": "warning",
+	"error.errors[]": "error",
+	"warning.errors[]": "error",
 	"chunk.modules[]": "module",
 	"chunk.rootModules[]": "module",
 	"chunk.origins[]": "chunkOrigin",
@@ -2500,6 +2571,8 @@ const MERGER = {
 	"compilation.namedChunkGroups": mergeToObject
 };
 
+const PLUGIN_NAME = "DefaultStatsFactoryPlugin";
+
 class DefaultStatsFactoryPlugin {
 	/**
 	 * Apply the plugin
@@ -2507,9 +2580,9 @@ class DefaultStatsFactoryPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsFactoryPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			compilation.hooks.statsFactory.tap(
-				"DefaultStatsFactoryPlugin",
+				PLUGIN_NAME,
 				/**
 				 * @param {StatsFactory} stats stats factory
 				 * @param {NormalizedStatsOptions} options stats options
@@ -2522,7 +2595,7 @@ class DefaultStatsFactoryPlugin {
 						(hookFor, fn) => {
 							stats.hooks.extract
 								.for(hookFor)
-								.tap("DefaultStatsFactoryPlugin", (obj, data, ctx) =>
+								.tap(PLUGIN_NAME, (obj, data, ctx) =>
 									fn(obj, data, ctx, options, stats)
 								);
 						}
@@ -2530,28 +2603,28 @@ class DefaultStatsFactoryPlugin {
 					iterateConfig(FILTER, options, (hookFor, fn) => {
 						stats.hooks.filter
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+							.tap(PLUGIN_NAME, (item, ctx, idx, i) =>
 								fn(item, ctx, options, idx, i)
 							);
 					});
 					iterateConfig(FILTER_RESULTS, options, (hookFor, fn) => {
 						stats.hooks.filterResults
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+							.tap(PLUGIN_NAME, (item, ctx, idx, i) =>
 								fn(item, ctx, options, idx, i)
 							);
 					});
 					iterateConfig(SORTERS, options, (hookFor, fn) => {
 						stats.hooks.sort
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+							.tap(PLUGIN_NAME, (comparators, ctx) =>
 								fn(comparators, ctx, options)
 							);
 					});
 					iterateConfig(RESULT_SORTERS, options, (hookFor, fn) => {
 						stats.hooks.sortResults
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+							.tap(PLUGIN_NAME, (comparators, ctx) =>
 								fn(comparators, ctx, options)
 							);
 					});
@@ -2562,27 +2635,25 @@ class DefaultStatsFactoryPlugin {
 						(hookFor, fn) => {
 							stats.hooks.groupResults
 								.for(hookFor)
-								.tap("DefaultStatsFactoryPlugin", (groupConfigs, ctx) =>
+								.tap(PLUGIN_NAME, (groupConfigs, ctx) =>
 									fn(groupConfigs, ctx, options)
 								);
 						}
 					);
 					for (const key of Object.keys(ITEM_NAMES)) {
 						const itemName = ITEM_NAMES[key];
-						stats.hooks.getItemName
-							.for(key)
-							.tap("DefaultStatsFactoryPlugin", () => itemName);
+						stats.hooks.getItemName.for(key).tap(PLUGIN_NAME, () => itemName);
 					}
 					for (const key of Object.keys(MERGER)) {
 						const merger = MERGER[key];
-						stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
+						stats.hooks.merge.for(key).tap(PLUGIN_NAME, merger);
 					}
 					if (options.children) {
 						if (Array.isArray(options.children)) {
 							stats.hooks.getItemFactory
 								.for("compilation.children[].compilation")
 								.tap(
-									"DefaultStatsFactoryPlugin",
+									PLUGIN_NAME,
 									/**
 									 * @param {Compilation} comp compilation
 									 * @param {StatsFactoryContext} options options
@@ -2605,7 +2676,7 @@ class DefaultStatsFactoryPlugin {
 							);
 							stats.hooks.getItemFactory
 								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", () => childFactory);
+								.tap(PLUGIN_NAME, () => childFactory);
 						}
 					}
 				}

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -55,6 +55,8 @@ const NAMED_PRESETS = {
 		optimizationBailout: true,
 		errorDetails: true,
 		errorStack: true,
+		errorCause: true,
+		errorErrors: true,
 		publicPath: true,
 		logging: "verbose",
 		orphanModules: true,
@@ -84,6 +86,8 @@ const NAMED_PRESETS = {
 		providedExports: true,
 		optimizationBailout: true,
 		errorDetails: true,
+		errorCause: true,
+		errorErrors: true,
 		publicPath: true,
 		logging: true,
 		runtimeModules: true,
@@ -260,6 +264,8 @@ const DEFAULTS = {
 	errorsCount: NORMAL_ON,
 	errorDetails: AUTO_FOR_TO_STRING,
 	errorStack: OFF_FOR_TO_STRING,
+	errorCause: AUTO_FOR_TO_STRING,
+	errorErrors: AUTO_FOR_TO_STRING,
 	warnings: NORMAL_ON,
 	warningsCount: NORMAL_ON,
 	publicPath: OFF_FOR_TO_STRING,
@@ -364,6 +370,8 @@ const NORMALIZER = {
 	}
 };
 
+const PLUGIN_NAME = "DefaultStatsPresetPlugin";
+
 class DefaultStatsPresetPlugin {
 	/**
 	 * Apply the plugin
@@ -371,35 +379,32 @@ class DefaultStatsPresetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsPresetPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			for (const key of Object.keys(NAMED_PRESETS)) {
 				const defaults = NAMED_PRESETS[/** @type {keyof NamedPresets} */ (key)];
 				compilation.hooks.statsPreset
 					.for(key)
-					.tap("DefaultStatsPresetPlugin", (options, context) => {
+					.tap(PLUGIN_NAME, (options, context) => {
 						applyDefaults(options, defaults);
 					});
 			}
-			compilation.hooks.statsNormalize.tap(
-				"DefaultStatsPresetPlugin",
-				(options, context) => {
-					for (const key of Object.keys(DEFAULTS)) {
-						if (options[key] === undefined)
-							options[key] =
-								/** @type {Defaults[DefaultsKeys]} */
-								(DEFAULTS[/** @type {DefaultsKeys} */ (key)])(
-									options,
-									context,
-									compilation
-								);
-					}
-					for (const key of Object.keys(NORMALIZER)) {
+			compilation.hooks.statsNormalize.tap(PLUGIN_NAME, (options, context) => {
+				for (const key of Object.keys(DEFAULTS)) {
+					if (options[key] === undefined)
 						options[key] =
-							/** @type {TODO} */
-							(NORMALIZER[/** @type {NormalizerKeys} */ (key)])(options[key]);
-					}
+							/** @type {Defaults[DefaultsKeys]} */
+							(DEFAULTS[/** @type {DefaultsKeys} */ (key)])(
+								options,
+								context,
+								compilation
+							);
+				}
+				for (const key of Object.keys(NORMALIZER)) {
+					options[key] =
+						/** @type {TODO} */
+						(NORMALIZER[/** @type {NormalizerKeys} */ (key)])(options[key]);
 				}
-			);
+			});
 		});
 	}
 }