@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/FileSystemInfo.js

@@ -8,11 +8,11 @@
 const nodeModule = require("module");
 const { isAbsolute } = require("path");
 const { create: createResolver } = require("enhanced-resolve");
-const asyncLib = require("neo-async");
 const { DEFAULTS } = require("./config/defaults");
 const { collectCjsRequireSpecifiers } = require("./javascript/syntax");
 const AsyncQueue = require("./util/AsyncQueue");
 const StackedCacheMap = require("./util/StackedCacheMap");
+const asyncLib = require("./util/async");
 const createHash = require("./util/createHash");
 const { dirname, join, lstatReadlinkAbsolute, relative } = require("./util/fs");
 const makeSerializable = require("./util/makeSerializable");
@@ -1884,10 +1884,13 @@ class FileSystemInfo {
 	 * Resolves build dependencies.
 	 * @param {string} context context directory
 	 * @param {Iterable<string>} deps dependencies
+	 * @param {Iterable<string> | undefined} optionalDeps optional dependencies that may be missing
 	 * @param {(err?: Error | null, resolveBuildDependenciesResult?: ResolveBuildDependenciesResult) => void} callback callback function
 	 * @returns {void}
 	 */
-	resolveBuildDependencies(context, deps, callback) {
+	resolveBuildDependencies(context, deps, optionalDeps, callback) {
+		/** @type {Set<string>} */
+		const optional = new Set(optionalDeps);
 		const { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild } =
 			this._createBuildDependenciesResolvers();
 
@@ -1979,7 +1982,7 @@ class FileSystemInfo {
 						type: RBDT_RESOLVE_INITIAL,
 						context,
 						path: dep,
-						expected: undefined,
+						expected: optional.has(dep) ? false : undefined,
 						issuer: undefined
 					})
 			),
@@ -2005,6 +2008,7 @@ class FileSystemInfo {
 							if (err) {
 								if (expected === false) {
 									resolveResults.set(key, false);
+									resolveMissing.add(path);
 									return callback();
 								}
 								invalidResolveResults.add(key);
@@ -2060,6 +2064,7 @@ class FileSystemInfo {
 								if (err) {
 									if (expected === false) {
 										resolveResults.set(key, false);
+										resolveMissing.add(path);
 										return callback();
 									}
 									invalidResolveResults.add(key);
@@ -2514,20 +2519,18 @@ class FileSystemInfo {
 			},
 			/**
 			 * Processes the provided err.
-			 * @param {Error | typeof INVALID=} err error or invalid flag
+			 * @param {(Error | typeof INVALID | null)=} err error or invalid flag
 			 * @returns {void}
 			 */
-			/** @type {import("neo-async").ErrorCallback<Error | typeof INVALID>} */ (
-				(err) => {
-					if (err === INVALID) {
-						return callback(null, false);
-					}
-					if (err) {
-						return callback(err);
-					}
-					return callback(null, true);
+			(err) => {
+				if (err === INVALID) {
+					return callback(null, false);
 				}
-			)
+				if (err) {
+					return callback(err);
+				}
+				return callback(null, true);
+			}
 		);
 	}
 

package/lib/FlagDependencyExportsPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const Queue = require("./util/Queue");
+const asyncLib = require("./util/async");
 const { compareModulesByIdentifier } = require("./util/comparators");
 const createHash = require("./util/createHash");
 
@@ -30,15 +30,40 @@ const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 /** @typedef {{ etag: string, data: InstanceType<RestoreProvidedData> }} MemCacheEntry */
 
 /**
+ * Cache key fragment for what changes provided exports without changing the
+ * module's source: still-lazy barrel requests and DefinePlugin value versions.
  * @param {Module} module the module
  * @param {LazyBarrelController} lazyBarrelController the compilation's lazy barrel controller
  * @param {HashFunction} hashFunction hash function for long keys
- * @returns {string} the hash
+ * @returns {string} etag for provided-exports mem/persistent cache, "" when neither applies
  */
-const getLazyRequestsHash = (module, lazyBarrelController, hashFunction) => {
-	const lazyKeys = lazyBarrelController.getLazyRequests(module);
-	if (!lazyKeys) return "";
-	const joined = [...lazyKeys].join("|");
+const getProvidedExportsEtag = (module, lazyBarrelController, hashFunction) => {
+	const lazyRequests = lazyBarrelController.getLazyRequests(module);
+	const buildInfo = /** @type {BuildInfo | undefined} */ (module.buildInfo);
+	const valueDependencies = buildInfo && buildInfo.valueDependencies;
+	const hasValueDependencies =
+		valueDependencies !== undefined && valueDependencies.size > 0;
+	if (!lazyRequests && !hasValueDependencies) return "";
+	/** @type {(string | string[] | undefined)[][]} */
+	const valueEntries = [];
+	if (hasValueDependencies) {
+		const versions =
+			/** @type {NonNullable<BuildInfo["valueDependencies"]>} */
+			(valueDependencies);
+		for (const key of [...versions.keys()].sort()) {
+			const value = versions.get(key);
+			// An absent version serializes as null, distinct from both other shapes
+			valueEntries.push([
+				key,
+				value instanceof Set ? [...value].sort() : value
+			]);
+		}
+	}
+	// JSON, so a separator inside a request or a version cannot forge another entry
+	const joined = JSON.stringify([
+		lazyRequests ? [...lazyRequests] : [],
+		valueEntries
+	]);
 	if (joined.length < 100) return joined;
 	const hash = createHash(hashFunction);
 	hash.update(joined);
@@ -78,9 +103,7 @@ class FlagDependencyExportsPlugin {
 					// Step 1: Try to restore cached provided export info from cache
 					logger.time("restore cached provided exports");
 					asyncLib.each(
-						/** @type {import("neo-async").IterableCollection<Module>} */ (
-							/** @type {unknown} */ (modules)
-						),
+						modules,
 						(module, callback) => {
 							const exportsInfo = moduleGraph.getExportsInfo(module);
 							// If the module doesn't have an exportsType, it's a module
@@ -109,16 +132,15 @@ class FlagDependencyExportsPlugin {
 							const memCache = moduleMemCaches && moduleMemCaches.get(module);
 							/** @type {MemCacheEntry | undefined} */
 							const memCacheEntry = memCache && memCache.get(this);
-							const hash = getLazyRequestsHash(
+							const etag = getProvidedExportsEtag(
 								module,
 								lazyBarrelController,
 								hashFunction
 							);
 							// validated by the still-lazy request keys: reference-change
-							// detection cannot invalidate the mem cache when the un-lazied
-							// connections are unsafe-cached (they are skipped when comparing
-							// references)
-							if (memCacheEntry !== undefined && memCacheEntry.etag === hash) {
+							// detection cannot invalidate the mem cache while the un-lazied
+							// connections are unsafe-cached, being skipped in the comparison
+							if (memCacheEntry !== undefined && memCacheEntry.etag === etag) {
 								statRestoredFromMemCache++;
 								exportsInfo.restoreProvided(memCacheEntry.data);
 								return callback();
@@ -128,7 +150,7 @@ class FlagDependencyExportsPlugin {
 							);
 							cache.get(
 								module.identifier(),
-								hash ? `${buildHash}|${hash}` : buildHash,
+								etag ? `${buildHash}|${etag}` : buildHash,
 								(err, result) => {
 									if (err) return callback(err);
 
@@ -149,16 +171,12 @@ class FlagDependencyExportsPlugin {
 							logger.timeEnd("restore cached provided exports");
 							if (err) return callback(err);
 
-							// Seed the queue with targets before the modules that read
-							// them. Enqueueing at the two branches above ordered the work by
-							// how fast each cache lookup answered — one is synchronous, the
-							// other a `cache.get` callback — so the persistent cache decided
-							// it. A module analysed before the module it re-exports from
-							// reads exports that are not determined yet and over-estimates,
-							// and this loop can add exports info but never retract it, so
-							// the over-estimate survives the pass that corrects it. The
-							// roots are sorted so the walk is stable, and post-order visits
-							// each module after everything it points at.
+							// WHY: enqueueing at the branches above ordered the work by how
+							// fast each cache lookup answered, letting the persistent cache
+							// decide it. A module analyzed before the one it re-exports from
+							// over-estimates its exports, and this loop can add exports info
+							// but never retract it, so that over-estimate would survive. Sorted
+							// roots and post-order visit each module after what it points at.
 							/** @type {Set<Module>} */
 							const visited = new Set();
 							/** @type {Module[]} */
@@ -351,12 +369,13 @@ class FlagDependencyExportsPlugin {
 												changed = true;
 											}
 
-											if (
-												inlined !== undefined &&
-												exportInfo.canInlineProvide === undefined
-											) {
-												exportInfo.canInlineProvide = inlined;
-												changed = true;
+											if (inlined !== undefined) {
+												const prev = exportInfo.canInlineProvide;
+												// Watch rebuilds keep ExportInfo; refresh when the constant changes
+												if (prev === undefined || !prev.equals(inlined)) {
+													exportInfo.canInlineProvide = inlined;
+													changed = true;
+												}
 											}
 
 											if (terminalBinding && !exportInfo.terminalBinding) {
@@ -513,7 +532,7 @@ class FlagDependencyExportsPlugin {
 										.getRestoreProvidedData();
 									const memCache =
 										moduleMemCaches && moduleMemCaches.get(module);
-									const hash = getLazyRequestsHash(
+									const etag = getProvidedExportsEtag(
 										module,
 										lazyBarrelController,
 										hashFunction
@@ -521,7 +540,7 @@ class FlagDependencyExportsPlugin {
 									if (memCache) {
 										/** @type {MemCacheEntry} */
 										const entry = {
-											etag: hash,
+											etag,
 											data: cachedData
 										};
 										memCache.set(this, entry);
@@ -531,7 +550,7 @@ class FlagDependencyExportsPlugin {
 									);
 									cache.store(
 										module.identifier(),
-										hash ? `${buildHash}|${hash}` : buildHash,
+										etag ? `${buildHash}|${etag}` : buildHash,
 										cachedData,
 										callback
 									);

package/lib/FlagDependencyUsagePlugin.js

@@ -93,10 +93,9 @@ class FlagDependencyUsagePlugin {
 					const processReferencedModule = (module, usedExports, runtime) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						if (usedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE) {
-							// The whole namespace object escapes via a reference that codegen
-							// can materialize as a decoupled namespace object. When all exports
-							// are statically known we keep them mangleable instead of marking
-							// them used-in-unknown-way.
+							// The namespace object escapes through a reference codegen can
+							// materialize, so with every export statically known they stay
+							// mangleable rather than used-in-unknown-way.
 							if (
 								this.mangleEscapingNamespaces &&
 								module.buildMeta &&
@@ -237,10 +236,9 @@ class FlagDependencyUsagePlugin {
 						/** @typedef {Map<string, string[] | ReferencedExport>} ExportMaps */
 						/** @type {Map<Module, ReferencedExports | ExportMaps>} */
 						const map = new Map();
-						// Modules whose whole namespace object escapes in a mangleable way.
-						// Tracked separately so specific member references are still merged
-						// (and marked used) instead of being dropped by the escape marker.
-						// Lazily allocated — usually empty.
+						// Modules whose whole namespace escapes but stays mangleable, kept
+						// apart so specific member references are still merged and marked
+						// used rather than dropped by the escape marker. Usually empty.
 						/** @type {Set<Module> | undefined} */
 						let mangleableEscapeModules;
 
@@ -289,11 +287,9 @@ class FlagDependencyUsagePlugin {
 									}
 									continue;
 								}
-								// A mangleable whole-object escape keeps the module's exports
-								// mangleable (applied after the merge). Unlike the conservative
-								// marker it must not drop specific member references: those still
-								// need their own (possibly non-existent) export marked used so
-								// they render as a qualified access, not a bare `undefined`.
+								// A mangleable escape keeps the exports mangleable, applied after
+								// the merge. It must not drop specific member references: each
+								// still needs marking, or it renders as a bare `undefined`.
 								if (
 									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
 								) {
@@ -345,10 +341,16 @@ class FlagDependencyUsagePlugin {
 											if (oldItem === undefined || Array.isArray(oldItem)) {
 												exportsMap.set(key, item);
 											} else {
+												// An unset flag means "allowed", so merge on `!== false`:
+												// `undefined && false` reads back as allowed.
 												exportsMap.set(key, {
 													name: item.name,
-													canMangle: item.canMangle && oldItem.canMangle,
-													canInline: item.canInline && oldItem.canInline
+													canMangle:
+														item.canMangle !== false &&
+														oldItem.canMangle !== false,
+													canInline:
+														item.canInline !== false &&
+														oldItem.canInline !== false
 												});
 											}
 										}

package/lib/Generator.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { contextifyStackFrames } = require("./ErrorHelpers");
 const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
 const memoize = require("./util/memoize");
 
@@ -23,6 +24,7 @@ const memoize = require("./util/memoize");
  * } from "./Module"
  */
 /** @import ModuleGraph from "./ModuleGraph" */
+/** @import RequestShortener from "./RequestShortener" */
 /** @import NormalModule from "./NormalModule" */
 /** @import RuntimeTemplate from "./RuntimeTemplate" */
 /** @import Hash from "./util/Hash" */
@@ -73,18 +75,38 @@ class Generator {
 		return new ByTypeGenerator(map);
 	}
 
+	/**
+	 * Returns what a module that failed to build says about it in the output.
+	 * The stack it carries is written relative to the context, keeping a
+	 * position only where a second build names the same one.
+	 * @param {Error} error the build error
+	 * @param {RequestShortener=} requestShortener request shortener, absolute paths are kept without one
+	 * @returns {string} message to emit
+	 */
+	static buildErrorMessage(error, requestShortener) {
+		return requestShortener
+			? contextifyStackFrames(error.message, requestShortener)
+			: error.message;
+	}
+
 	/**
 	 * Returns the statement a module that failed to build throws when executed.
 	 * @param {Error} error the build error
 	 * @param {string=} parseErrorConstructor constructor for a rejected source, defaults to `SyntaxError` (WebAssembly rejects with `WebAssembly.CompileError` instead)
+	 * @param {RequestShortener=} requestShortener request shortener for the stack the message carries
 	 * @returns {string} javascript statement
 	 */
-	static throwBuildErrorCode(error, parseErrorConstructor = "SyntaxError") {
+	static throwBuildErrorCode(
+		error,
+		parseErrorConstructor = "SyntaxError",
+		requestShortener = undefined
+	) {
 		// A source the parser rejected throws what a native load of it would.
 		const name =
 			error instanceof getModuleParseError() ? parseErrorConstructor : "Error";
+		const message = Generator.buildErrorMessage(error, requestShortener);
 
-		return `throw new ${name}(${JSON.stringify(error.message)});`;
+		return `throw new ${name}(${JSON.stringify(message)});`;
 	}
 
 	/* istanbul ignore next */

package/lib/HotModuleReplacementPlugin.js

@@ -17,7 +17,11 @@ const {
 } = require("./ModuleTypeConstants");
 const NormalModule = require("./NormalModule");
 const RuntimeGlobals = require("./RuntimeGlobals");
-const { chunkHasCss } = require("./css/CssModulesPlugin");
+const { getPresentKinds } = require("./TemplatedPathPlugin");
+const {
+	chunkHasCss,
+	getChunkFilenameTemplate: getCssChunkFilenameTemplate
+} = require("./css/CssModulesPlugin");
 const ConstDependency = require("./dependencies/ConstDependency");
 const ImportMetaHotAcceptDependency = require("./dependencies/ImportMetaHotAcceptDependency");
 const ImportMetaHotDeclineDependency = require("./dependencies/ImportMetaHotDeclineDependency");
@@ -72,6 +76,24 @@ const {
 /** @typedef {{ updatedChunkIds: ChunkIds, removedChunkIds: ChunkIds, removedModules: ModuleSet, forceLoadChunkIds: ChunkIds, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */
 /** @typedef {Map<string, HotUpdateMainContentByRuntimeItem>} HotUpdateMainContentByRuntime */
 
+/** @typedef {{ hot?: boolean }} HotModuleReplacementPluginLoaderContext */
+
+/**
+ * Whether a filename template reads any hash, so the name it gives a chunk can move
+ * between two builds.
+ * @param {string} template the filename template
+ * @returns {boolean} true when a hash is part of the name
+ */
+const templateReadsHash = (template) => {
+	const kinds = getPresentKinds(template);
+	return (
+		kinds.has("hash") ||
+		kinds.has("fullhash") ||
+		kinds.has("chunkhash") ||
+		kinds.has("contenthash")
+	);
+};
+
 const PLUGIN_NAME = "HotModuleReplacementPlugin";
 
 class HotModuleReplacementPlugin {
@@ -856,7 +878,7 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 								assetInfo
 							}
 						] of hotUpdateMainContentByFilename) {
-							/** @type {{ c: ChunkId[], r: ChunkId[], m: ModuleId[], f?: ChunkId[], css?: { r: ChunkId[] } }} */
+							/** @type {{ c: ChunkId[], r: ChunkId[], m: ModuleId[], f?: ChunkId[], css?: { r: ChunkId[], n?: Record<ChunkId, string> } }} */
 							const hotUpdateMainJson = {
 								c: [...updatedChunkIds],
 								r: [...removedChunkIds],
@@ -882,21 +904,47 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 							// Build CSS removed chunks list (chunks in updatedChunkIds that no longer have CSS)
 							/** @type {ChunkId[]} */
 							const cssRemovedChunkIds = [];
+							/** @type {Record<ChunkId, string> | undefined} */
+							let cssChunkNames;
 							if (compilation.options.experiments.css) {
 								for (const chunkId of updatedChunkIds) {
 									for (const /** @type {Chunk} */ chunk of compilation.chunks) {
-										if (chunk.id === chunkId) {
-											if (!chunkHasCss(chunk, chunkGraph)) {
-												cssRemovedChunkIds.push(chunkId);
-											}
+										if (chunk.id !== chunkId) continue;
+										if (!chunkHasCss(chunk, chunkGraph)) {
+											cssRemovedChunkIds.push(chunkId);
 											break;
 										}
+										// The runtime's name map is refreshed only by the update chunk
+										// itself, so a name that moved with the content travels here.
+										const template = getCssChunkFilenameTemplate(
+											chunk,
+											compilation.outputOptions
+										);
+										if (
+											typeof template !== "string" ||
+											templateReadsHash(template)
+										) {
+											if (cssChunkNames === undefined) cssChunkNames = {};
+											cssChunkNames[chunkId] = compilation.getPath(template, {
+												hash: compilation.hash,
+												runtime: chunk.runtime,
+												chunk,
+												contentHashType: "css"
+											});
+										}
+										break;
 									}
 								}
 							}
 
-							if (cssRemovedChunkIds.length > 0) {
+							if (
+								cssRemovedChunkIds.length > 0 ||
+								cssChunkNames !== undefined
+							) {
 								hotUpdateMainJson.css = { r: cssRemovedChunkIds };
+								if (cssChunkNames !== undefined) {
+									hotUpdateMainJson.css.n = cssChunkNames;
+								}
 							}
 
 							const source = new RawSource(

package/lib/IgnorePlugin.js

@@ -15,7 +15,7 @@ const EntryDependency = require("./dependencies/EntryDependency");
  */
 /** @import Compiler from "./Compiler" */
 /** @import { ResolveData } from "./NormalModuleFactory" */
-/** @import { BeforeContextResolveData } from "./ContextModuleFactory" */
+/** @import { BeforeContextResolveData } from "./context/ContextModuleFactory" */
 
 /** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */
 

package/lib/JavascriptMetaInfoPlugin.js

@@ -11,6 +11,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("./ModuleTypeConstants");
 const { getInnerGraphUtils } = require("./optimize/InnerGraph");
+const { recordOptimizationBailout } = require("./util/buildDiagnostics");
 
 /** @import Compiler from "./Compiler" */
 /** @import { BuildInfo } from "./Module" */
@@ -73,9 +74,10 @@ class JavascriptMetaInfoPlugin {
 							const wasEnabled = innerGraph.isEnabled(parser.state);
 							innerGraph.bailout(parser.state);
 							if (wasEnabled) {
-								compilation.moduleGraph
-									.getOptimizationBailout(parser.state.module)
-									.push("Inner graph bailout: eval()");
+								recordOptimizationBailout(
+									buildInfo,
+									"Inner graph bailout: eval()"
+								);
 							}
 						}
 					});

package/lib/LoaderOptionsPlugin.js

@@ -19,7 +19,7 @@ const NormalModule = require("./NormalModule");
 /**
  * Defines the loader context type used by this module.
  * @template T
- * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ * @typedef {import("./NormalModule").LoaderContext<T>} LoaderContext
  */
 
 const PLUGIN_NAME = "LoaderOptionsPlugin";

package/lib/MainTemplate.js

@@ -21,7 +21,11 @@ const getJsonpTemplatePlugin = memoize(() =>
 
 /** @import { Tap } from "tapable" */
 /** @import { Source } from "webpack-sources" */
-/** @import { Output as OutputOptions } from "../declarations/WebpackOptions" */
+/**
+ * @import {
+ * 	OutputNormalizedWithDefaults as OutputOptions
+ * } from "./config/defaults"
+ */
 /** @import ModuleTemplate from "./ModuleTemplate" */
 /** @import Chunk from "./Chunk" */
 /**

package/lib/Module.js

@@ -128,6 +128,10 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {Set<string>} topLevelDeclarations top level declarations for javascript modules
  * @property {Set<string>} freeNames free identifier names in the rendered source for javascript modules
  * @property {InitFragment<EXPECTED_ANY>[]} chunkInitFragments chunk init fragments for javascript modules
+ * @property {string} externalReexport native external reexport source and attributes
+ * @property {string} exportsSource export definitions left out of a javascript module's source on demand (see `KnownMeta.onDemandExports`), to be placed before its body where it is wrapped
+ * @property {string} exportsBindingSource export definitions left out on demand that read the module's own declarations, to be placed after its body where it is wrapped
+ * @property {Record<string, string>} exportsFinalName final name of each used export of a concatenated module whose definitions were left out on demand
  * @property {{ javascript?: string, ["asset-url"]?: string }} url url for asset modules
  * @property {string} filename a filename for asset modules
  * @property {AssetInfo} assetInfo an asset info for asset modules
@@ -181,28 +185,35 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {(false | "redirect" | "redirect-warn")=} defaultObject
  * @property {boolean=} async
  * @property {boolean=} sideEffectFree
- * @property {Map<string, Record<string, string>>=} exportsFinalNameByRuntime using in ModuleLibraryPlugin
- * @property {Map<string, string>=} exportsSourceByRuntime using in ModuleLibraryPlugin
- * @property {Map<string, string>=} exportsBindingSourceByRuntime export definitions `ModuleLibraryPlugin` took over, re-emitted only where the module is wrapped
+ */
+
+/**
+ * What a build recorded for stats and the performance hints to report, kept on the build info so a module restored from the cache still has it.
+ * @typedef {object} BuildDiagnostics
+ * @property {string[]=} optimizationBailouts what parser plugins reported as optimization bailouts, replayed into the module graph of every compilation that reuses the module
+ * @property {string=} sideEffectStatement the statement whose side effect keeps the module in the bundle, as `type at location`
+ * @property {number=} ineffectivePureAnnotations how many `#__PURE__` annotations sit where the parser does not read them
+ * @property {number=} topLevelThis how many times the module reads `this` at its top level
+ * @property {boolean=} usesEval true when the module calls `eval` directly
+ * @property {string[]=} notCacheableReasons reasons why the module is not cacheable (e.g. paths of loaders that marked it)
  */
 
 /**
  * Defines the build info properties common to all module types.
  * Module type specific properties live in the `Known*BuildInfo` typedef of the dedicated module class.
  * @typedef {object} KnownBuildInfo
+ * @property {boolean=} specNamespaceObject the module hands out a spec Module Namespace Exotic Object
  * @property {boolean=} cacheable
- * @property {string[]=} notCacheableReasons reasons why the module is not cacheable (e.g. paths of loaders that marked it)
  * @property {boolean=} strict
  * @property {string=} moduleArgument
  * @property {string=} exportsArgument
  * @property {Record<string, Source>=} assets assets added by loaders or plugins
  * @property {Map<string, AssetInfo | undefined>=} assetsInfo
  * @property {Set<string>=} topLevelDeclarations top level declaration names
- * @property {boolean=} isCircular true when the module is part of a circular dependency chain
- * @property {boolean=} usesEval true when the module calls `eval` directly
- * @property {number=} ineffectivePureAnnotations how many `#__PURE__` annotations sit where the parser does not read them
- * @property {number=} topLevelThis how many times the module reads `this` at its top level
+ * @property {boolean=} isCircular true when the module is in a synchronous circular dependency chain
+ * @property {number=} circularKind CircularKind bit flags from CircularModulesPlugin; unset when the plugin did not run
  * @property {boolean=} usesTopLevelAwaitForOf module uses top-level `for await…of` or `await using`, which can't be lowered to a generator
+ * @property {BuildDiagnostics=} diagnostics what the build recorded for stats and the performance hints to report
  */
 
 /** @typedef {string | Set<string>} ValueCacheVersion */
@@ -1310,7 +1321,6 @@ class Module extends DependenciesBlock {
 		write(this.type);
 		write(this.layer);
 		write(this.context);
-		write(this.resolveOptions);
 		write(this.factoryMeta);
 		write(this.useSourceMap);
 		write(this.useSimpleSourceMap);
@@ -1340,7 +1350,6 @@ class Module extends DependenciesBlock {
 		this.type = read();
 		this.layer = read();
 		this.context = read();
-		this.resolveOptions = read();
 		this.factoryMeta = read();
 		this.useSourceMap = read();
 		this.useSimpleSourceMap = read();

package/lib/ModuleGraph.js

@@ -143,6 +143,7 @@ class ModuleGraphModule {
  * @typedef {object} KnownMeta
  * @property {Map<Module, string>=} importVarMap
  * @property {Map<Module, string>=} deferredImportVarMap
+ * @property {boolean=} onDemandExports generate export definitions on demand
  */
 
 /** @typedef {KnownMeta & Record<CommonJsExportRequireDependencyIDsSymbol | HarmonyImportSpecifierDependencyIDsSymbol | HarmonyExportImportedSpecifierDependencyIDsSymbol, string[]> & Record<string, EXPECTED_ANY>} Meta */
@@ -342,10 +343,8 @@ class ModuleGraph {
 		}
 		const originDependency = connection.dependency;
 
-		// src/index.js
-		// import { c } from "lib/c" -> c = 0
-		// import { a, b } from "lib" -> a and b have the same source order -> a = b = 1
-		// import { d } from "lib/d" -> d = 2
+		// Specifiers of one import statement share its source order, so `a` and `b`
+		// of `import { a, b } from "lib"` both take the statement's index.
 		const currentSourceOrder =
 			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
 			(dependency).sourceOrder;
@@ -360,11 +359,9 @@ class ModuleGraph {
 			typeof currentSourceOrder === "number" &&
 			typeof originSourceOrder === "number"
 		) {
-			// src/index.js
-			// import { c } from "lib/c" -> c = 0
-			// import { a } from "lib/a" -> a = 1.0 = 1(main) + 0.0(sub)
-			// import { b } from "lib/b" -> b = 1.1 = 1(main) + 0.1(sub)
-			// import { d } from "lib/d" -> d = 2
+			// A re-exported specifier keeps the importing statement's order as `main`
+			// and its own position as `sub`, so the pair orders it within that
+			// statement without disturbing the statements around it.
 			this._dependencySourceOrderMap.set(dependency, {
 				main: currentSourceOrder,
 				sub: originSourceOrder