webpack 5.107.1 → 5.108.0

package/types.d.ts

@@ -129,6 +129,10 @@ import { Context as ContextImport } from "vm";
 declare interface Abortable {
 	signal?: AbortSignal;
 }
+
+/**
+ * Represents AbstractLibraryPlugin.
+ */
 declare class AbstractLibraryPlugin<T> {
 	/**
 	 * Creates an instance of AbstractLibraryPlugin.
@@ -311,16 +315,17 @@ declare interface AliasOption {
 	name: string;
 	onlyModule?: boolean;
 }
-type AliasOptionNewRequest = string | false | string[];
-declare interface AliasOptions {
-	[index: string]: AliasOptionNewRequest;
-}
 declare interface AllCodeGenerationSchemas {
 	/**
 	 * top level declarations for javascript modules
 	 */
 	topLevelDeclarations: Set<string>;
 
+	/**
+	 * free identifier names in the rendered source for javascript modules
+	 */
+	freeNames: Set<string>;
+
 	/**
 	 * chunk init fragments for javascript modules
 	 */
@@ -355,36 +360,6 @@ type AnyLoaderContext = NormalModuleLoaderContext<any> &
 	LoaderRunnerLoaderContext<any> &
 	LoaderPluginLoaderContext &
 	HotModuleReplacementPluginLoaderContext;
-declare abstract class AppendOnlyStackedSet<T> {
-	/**
-	 * Adds a value to the current scope layer, creating that layer lazily when
-	 * the first write occurs.
-	 */
-	add(el: T): void;
-
-	/**
-	 * Checks whether a value is present in any scope layer currently visible to
-	 * this stacked set.
-	 */
-	has(el: T): boolean;
-
-	/**
-	 * Removes every scope layer and any values accumulated in them.
-	 */
-	clear(): void;
-
-	/**
-	 * Creates a child stacked set that shares the existing scope history while
-	 * allowing subsequent additions to be recorded in its own new layer.
-	 */
-	createChild(): AppendOnlyStackedSet<T>;
-
-	/**
-	 * Iterates over the stacked sets from newest to oldest so consumers can
-	 * inspect recently added values first.
-	 */
-	[Symbol.iterator](): Iterator<T>;
-}
 
 /**
  * Returns object of arguments.
@@ -521,6 +496,10 @@ declare interface AssetInlineGeneratorOptions {
 				context: { filename: string; module: Module }
 		  ) => string);
 }
+type AssetModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownNormalModuleBuildInfo &
+	KnownAssetModuleBuildInfo;
 declare abstract class AssetParser extends ParserClass {
 	dataUrlCondition?:
 		| boolean
@@ -609,6 +588,10 @@ declare class AsyncDependenciesBlock extends DependenciesBlock {
 	get circular(): boolean;
 	module: any;
 }
+
+/**
+ * Represents AsyncQueue.
+ */
 declare abstract class AsyncQueue<T, K, R> {
 	hooks: {
 		beforeAdd: AsyncSeriesHook<[T]>;
@@ -711,6 +694,11 @@ declare interface AsyncWebAssemblyModulesPluginOptions {
 	mangleImports?: boolean;
 }
 declare abstract class AsyncWebAssemblyParser extends ParserClass {}
+
+/**
+ * Records modules from one compilation and adds them back as prefetch
+ * dependencies in the next compilation.
+ */
 declare class AutomaticPrefetchPlugin {
 	constructor();
 
@@ -725,6 +713,11 @@ declare interface BackendApi {
 	dispose: (callback: (err?: null | Error) => void) => void;
 	module: (module: Module) => ModuleResult;
 }
+
+/**
+ * Prepends or appends banner text to emitted assets that match the configured
+ * file filters.
+ */
 declare class BannerPlugin {
 	/**
 	 * Normalizes banner options and compiles the configured banner source into a
@@ -847,6 +840,11 @@ declare interface BaseResolveRequest {
 	 * inner relative path for internal usage
 	 */
 	__innerRequest_relativePath?: string;
+
+	/**
+	 * internal: shared marker `RestrictionsPlugin` flips when it filters out an existing target, letting `ExportsFieldPlugin` fall back instead of erroring
+	 */
+	__restrictionsMarker?: { blocked: boolean };
 }
 declare interface BasenameCacheEntry {
 	/**
@@ -1269,6 +1267,11 @@ declare abstract class ByTypeGenerator extends Generator {
 	) => null | Source;
 }
 declare const CIRCULAR_CONNECTION: unique symbol;
+
+/**
+ * Abstract cache interface backed by tapable hooks for reading, writing, idle
+ * transitions, and shutdown across webpack cache implementations.
+ */
 declare class CacheClass {
 	/**
 	 * Initializes the cache lifecycle hooks implemented by cache backends.
@@ -1552,6 +1555,11 @@ declare interface CallbackWebpackFunction_2<T, R = void> {
 	(err: null | Error, result?: T): R;
 }
 type Cell<T> = undefined | T;
+
+/**
+ * A Chunk is a unit of encapsulation for Modules.
+ * Chunks are "rendered" into bundles that get emitted when the build completes.
+ */
 declare class Chunk {
 	/**
 	 * Creates an instance of Chunk.
@@ -1575,6 +1583,7 @@ declare class Chunk {
 	rendered: boolean;
 	hash?: string;
 	contentHash: Record<string, string>;
+	contentHashFull: Record<string, string>;
 	renderedHash?: string;
 	chunkReason?: string;
 	extraAsync: boolean;
@@ -2368,6 +2377,11 @@ declare class ChunkGraph {
 	 */
 	static clearChunkGraphForChunk(chunk: Chunk): void;
 }
+
+/**
+ * Represents a connected group of chunks along with the parent/child
+ * relationships, async blocks, and traversal metadata webpack tracks for it.
+ */
 declare abstract class ChunkGroup {
 	groupDebugId: number;
 	options: ChunkGroupOptions;
@@ -2672,9 +2686,27 @@ declare interface ChunkPathData {
 	name?: string;
 	hash: string;
 	hashWithLength?: (length: number) => string;
+
+	/**
+	 * builds `[chunkhash:<digest>]` per chunk in the runtime chunk-filename map
+	 */
+	hashWithDigest?: (digest: string, length?: number) => string;
 	contentHash?: Record<string, string>;
 	contentHashWithLength?: Record<string, (length: number) => string>;
+
+	/**
+	 * builds `[contenthash:<digest>]` per chunk in the runtime chunk-filename map
+	 */
+	contentHashWithDigest?: Record<
+		string,
+		(digest: string, length?: number) => string
+	>;
 }
+
+/**
+ * Adds runtime support for chunk prefetch and preload relationships discovered
+ * in the chunk graph.
+ */
 declare class ChunkPrefetchPreloadPlugin {
 	constructor();
 
@@ -2886,6 +2918,22 @@ declare interface CleanPluginCompilationHooks {
 	 */
 	keep: SyncBailHook<[string], boolean | void>;
 }
+declare interface ClearCacheOptions {
+	/**
+	 * drop cached source maps (default `true`)
+	 */
+	maps?: boolean;
+
+	/**
+	 * drop cached source/buffer copies (default `true`)
+	 */
+	source?: boolean;
+
+	/**
+	 * drop the parsed object form of cached source maps on `SourceMapSource` instances (default `false` — re-parsing JSON is significantly more expensive than `toString`). Only takes effect when a serialized form (buffer or string) is also retained, so the data remains recoverable.
+	 */
+	parsedMap?: boolean;
+}
 declare interface CodeGenMapOverloads {
 	get: <K extends string>(key: K) => undefined | CodeGenValue<K>;
 	set: <K extends string>(
@@ -2900,6 +2948,7 @@ type CodeGenValue<K extends string> = K extends
 	| "assetInfo"
 	| "share-init"
 	| "topLevelDeclarations"
+	| "freeNames"
 	| "chunkInitFragments"
 	| "url"
 	| "fullContentHash"
@@ -2988,6 +3037,11 @@ type CodeGenerationResultData = Omit<
 	"get" | "set" | "has" | "delete"
 > &
 	CodeGenMapOverloads;
+
+/**
+ * Stores code generation results keyed by module and runtime so later stages
+ * can retrieve emitted sources, metadata, and derived hashes.
+ */
 declare abstract class CodeGenerationResults {
 	map: Map<Module, RuntimeSpecMap<CodeGenerationResult, CodeGenerationResult>>;
 
@@ -3131,11 +3185,6 @@ declare interface ColorsOptions {
 	 */
 	useColor?: boolean;
 }
-declare interface CommentCssParser {
-	value: string;
-	range: [number, number];
-	loc: { start: Position; end: Position };
-}
 type CommentJavascriptParser = CommentImport & {
 	start: number;
 	end: number;
@@ -4038,6 +4087,27 @@ declare interface CompiledAliasOption {
 	 */
 	arrayAlias: boolean;
 }
+declare interface CompiledAliasOptions {
+	/**
+	 * declaration-ordered list
+	 */
+	all: CompiledAliasOption[];
+
+	/**
+	 * bucketed by first char code
+	 */
+	byFirstChar: Map<number, CompiledAliasOption[]>;
+
+	/**
+	 * true when an empty-prefix wildcard is present
+	 */
+	hasAnyFirstChar: boolean;
+
+	/**
+	 * true when the bucket fast-path should be used at resolve time
+	 */
+	useBuckets: boolean;
+}
 declare class Compiler {
 	/**
 	 * Creates an instance of Compiler.
@@ -4271,6 +4341,9 @@ declare class ConcatSource extends Source {
 	): GeneratedSourceInfo;
 }
 type ConcatSourceChild = string | Source | SourceLike;
+type ConcatenatedModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownConcatenatedModuleBuildInfo;
 declare interface ConcatenatedModuleInfo {
 	type: "concatenated";
 	module: Module;
@@ -4287,6 +4360,11 @@ declare interface ConcatenatedModuleInfo {
 	rawExportMap?: Map<string, string>;
 	namespaceExportSymbol?: string;
 	namespaceObjectName?: string;
+
+	/**
+	 * decoupled namespace object that keeps original export names when the exports are mangled
+	 */
+	escapeNamespaceObjectName?: string;
 	concatenationScope?: ConcatenationScope;
 
 	/**
@@ -4318,6 +4396,24 @@ declare interface ConcatenatedModuleInfo {
 	 * runtime namespace object that detects "__esModule"
 	 */
 	interopDefaultAccessName?: string;
+
+	/**
+	 * memoized getExportsType(strict=true)
+	 */
+	exportsTypeStrict?:
+		| "namespace"
+		| "dynamic"
+		| "default-only"
+		| "default-with-named";
+
+	/**
+	 * memoized getExportsType(strict=false)
+	 */
+	exportsTypeNonStrict?:
+		| "namespace"
+		| "dynamic"
+		| "default-only"
+		| "default-with-named";
 }
 declare interface ConcatenationBailoutReasonContext {
 	/**
@@ -4330,6 +4426,11 @@ declare interface ConcatenationBailoutReasonContext {
 	 */
 	chunkGraph: ChunkGraph;
 }
+
+/**
+ * Tracks the symbols and cross-module references needed while rendering a
+ * concatenated module.
+ */
 declare class ConcatenationScope {
 	/**
 	 * Creates the mutable scope object used while rendering a concatenated
@@ -4696,8 +4797,20 @@ declare class ConstDependency extends NullDependency {
 	range: number | [number, number];
 	runtimeRequirements: null | Set<string>;
 	static Template: typeof ConstDependencyTemplate;
+
+	/**
+	 * Compares two dependencies by source location for sorting a module's
+	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
+	 * its result, so comparing through it would retain a location object on every
+	 * sorted dependency). These dependencies always carry a real source position,
+	 * so only start (line, column) and the within-statement index are compared; a
+	 * dependency without an index sorts after one that has an index at the same
+	 * position.
+	 */
+	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];
 
 	/**
 	 * Returns true if the dependency is a low priority dependency.
@@ -4709,6 +4822,10 @@ declare class ConstDependency extends NullDependency {
 	 */
 	static canConcatenate(dependency: Dependency): boolean;
 	static TRANSITIVE: symbol;
+	static LAZY_UNTIL_LOCAL: "local";
+	static LAZY_UNTIL_ID: "id";
+	static LAZY_UNTIL_FALLBACK: "*";
+	static LAZY_UNTIL_REQUEST: "@";
 }
 declare class ConstDependencyTemplate extends NullDependencyTemplate {
 	constructor();
@@ -4912,12 +5029,15 @@ declare interface ContextHash {
 	symlinks?: Set<string>;
 }
 type ContextMode =
-	| "weak"
 	| "eager"
+	| "weak"
 	| "lazy"
 	| "lazy-once"
 	| "sync"
 	| "async-weak";
+type ContextModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownContextModuleBuildInfo;
 declare abstract class ContextModuleFactory extends ModuleFactory {
 	hooks: Readonly<{
 		beforeResolve: AsyncSeriesWaterfallHook<
@@ -5152,6 +5272,11 @@ declare interface CssAutoOrModuleParserOptions {
 	 */
 	animation?: boolean;
 
+	/**
+	 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
+	 */
+	as?: "stylesheet" | "block-contents";
+
 	/**
 	 * Enable/disable renaming of `@container` names.
 	 */
@@ -5317,6 +5442,13 @@ declare abstract class CssModule extends NormalModule {
 	inheritance?: [CssLayer, Supports, Media][];
 	exportType?: "link" | "text" | "css-style-sheet" | "style";
 }
+type CssModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownNormalModuleBuildInfo &
+	KnownCssModuleBuildInfo;
+type CssModuleBuildMeta = KnownBuildMeta &
+	Record<string, any> &
+	KnownCssModuleBuildMeta;
 
 /**
  * Generator options for css/module modules.
@@ -5383,6 +5515,11 @@ declare interface CssModuleParserOptions {
 	 */
 	animation?: boolean;
 
+	/**
+	 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
+	 */
+	as?: "stylesheet" | "block-contents";
+
 	/**
 	 * Enable/disable renaming of `@container` names.
 	 */
@@ -5492,12 +5629,16 @@ declare class CssModulesPlugin {
 	static chunkHasCss(chunk: Chunk, chunkGraph: ChunkGraph): boolean;
 }
 declare abstract class CssParser extends ParserClass {
-	defaultMode: "global" | "auto" | "pure" | "local";
+	defaultMode: "global" | "auto" | "local" | "pure";
 	options: {
 		/**
 		 * Enable/disable renaming of `@keyframes`.
 		 */
 		animation: boolean;
+		/**
+		 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
+		 */
+		as: string;
 		/**
 		 * Enable/disable renaming of `@container` names.
 		 */
@@ -5541,29 +5682,20 @@ declare abstract class CssParser extends ParserClass {
 		/**
 		 * default mode
 		 */
-		defaultMode?: "global" | "auto" | "pure" | "local";
+		defaultMode?: "global" | "auto" | "local" | "pure";
 	};
-	comments?: CommentCssParser[];
 	magicCommentContext: ContextImport;
-
-	/**
-	 * Returns comments in the range.
-	 */
-	getComments(range: [number, number]): CommentCssParser[];
-
-	/**
-	 * Parses comment options.
-	 */
-	parseCommentOptions(range: [number, number]): {
-		options: null | Record<string, any>;
-		errors: null | (Error & { comment: CommentCssParser })[];
-	};
 }
 
 /**
  * Parser options for css modules.
  */
 declare interface CssParserOptions {
+	/**
+	 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
+	 */
+	as?: "stylesheet" | "block-contents";
+
 	/**
 	 * Configure how CSS content is exported as default.
 	 */
@@ -5585,6 +5717,29 @@ declare interface CssParserOptions {
 	url?: boolean;
 }
 type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+type DefineConfigInput =
+	| Configuration
+	| MultiConfiguration
+	| ((
+			env: Record<string, any>,
+			argv: Record<string, any>
+	  ) => MaybePromise<Configuration | MultiConfiguration>)
+	| ((
+			env: Record<string, any>,
+			argv: Record<string, any>
+	  ) => MaybePromise<Configuration | MultiConfiguration>)[]
+	| Promise<
+			| Configuration
+			| MultiConfiguration
+			| ((
+					env: Record<string, any>,
+					argv: Record<string, any>
+			  ) => MaybePromise<Configuration | MultiConfiguration>)
+			| ((
+					env: Record<string, any>,
+					argv: Record<string, any>
+			  ) => MaybePromise<Configuration | MultiConfiguration>)[]
+	  >;
 declare class DefinePlugin {
 	/**
 	 * Create a new define plugin
@@ -5635,6 +5790,15 @@ declare class DelegatedPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+
+/**
+ * DependenciesBlock is the base class for all Module classes in webpack. It describes a
+ * "block" of dependencies which are pointers to other DependenciesBlock instances. For example
+ * when a Module has a CommonJs require statement, the DependencyBlock for the CommonJs module
+ * would be added as a dependency to the Module. DependenciesBlock is inherited by two types of classes:
+ * Module subclasses and AsyncDependenciesBlock subclasses. The only difference between the two is that
+ * AsyncDependenciesBlock subclasses are used for code-splitting (async boundary) and Module subclasses are not.
+ */
 declare abstract class DependenciesBlock {
 	dependencies: Dependency[];
 	blocks: AsyncDependenciesBlock[];
@@ -5670,12 +5834,12 @@ declare abstract class DependenciesBlock {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContext): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContext): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
 }
 declare interface DependenciesBlockLike {
 	dependencies: Dependency[];
@@ -5683,7 +5847,6 @@ declare interface DependenciesBlockLike {
 }
 declare class Dependency {
 	constructor();
-	weak: boolean;
 	optional?: boolean;
 
 	/**
@@ -5711,6 +5874,14 @@ declare class Dependency {
 		endColumn: number
 	): void;
 
+	/**
+	 * Updates loc from a source location plus an explicit index, without
+	 * materializing the `loc` object (keeps `get loc` lazy). Replaces the
+	 * `dep.loc = Object.create(loc); dep.loc.index = i` pattern, which both
+	 * allocated a copy and stored the index outside the serialized fields.
+	 */
+	setLocWithIndex(loc: DependencyLocation, index: number): void;
+
 	/**
 	 * Returns a request context.
 	 */
@@ -5726,6 +5897,31 @@ declare class Dependency {
 	 */
 	couldAffectReferencingModule(): boolean | symbol;
 
+	/**
+	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
+	 */
+	getForwardId(): null | string | true;
+
+	/**
+	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
+	 */
+	getLazyUntil(): null | "local" | "id" | "*" | "@";
+
+	/**
+	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 */
+	getLazyName(): null | string;
+
+	/**
+	 * Whether the lazy barrel currently defers creating this dependency's target module (lazy barrel optimization).
+	 */
+	isLazy(): boolean;
+
+	/**
+	 * Sets whether the lazy barrel defers creating this dependency's target module (lazy barrel optimization).
+	 */
+	setLazy(value: boolean): void;
+
 	/**
 	 * Returns the referenced module and export
 	 * @deprecated
@@ -5798,16 +5994,28 @@ declare class Dependency {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContext): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContext): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
 	module: any;
 	get disconnect(): any;
+
+	/**
+	 * Compares two dependencies by source location for sorting a module's
+	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
+	 * its result, so comparing through it would retain a location object on every
+	 * sorted dependency). These dependencies always carry a real source position,
+	 * so only start (line, column) and the within-statement index are compared; a
+	 * dependency without an index sorts after one that has an index at the same
+	 * position.
+	 */
+	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];
 
 	/**
 	 * Returns true if the dependency is a low priority dependency.
@@ -5819,6 +6027,10 @@ declare class Dependency {
 	 */
 	static canConcatenate(dependency: Dependency): boolean;
 	static TRANSITIVE: symbol;
+	static LAZY_UNTIL_LOCAL: "local";
+	static LAZY_UNTIL_ID: "id";
+	static LAZY_UNTIL_FALLBACK: "*";
+	static LAZY_UNTIL_REQUEST: "@";
 }
 declare interface DependencyConstructor {
 	new (...args: any[]): Dependency;
@@ -6409,7 +6621,37 @@ declare class ElectronTargetPlugin {
 	/**
 	 * Creates an instance of ElectronTargetPlugin.
 	 */
-	constructor(context?: "main" | "preload" | "renderer");
+	constructor(
+		context?: "main" | "preload" | "renderer",
+		type?:
+			| "import"
+			| "var"
+			| "module"
+			| "assign"
+			| "this"
+			| "window"
+			| "self"
+			| "global"
+			| "commonjs"
+			| "commonjs2"
+			| "commonjs-module"
+			| "commonjs-static"
+			| "amd"
+			| "amd-require"
+			| "umd"
+			| "umd2"
+			| "jsonp"
+			| "system"
+			| "promise"
+			| "module-import"
+			| "script"
+			| "node-commonjs"
+			| "asset"
+			| "asset-url"
+			| "css-import"
+			| "css-url"
+	);
+	type: ExternalsType;
 
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
@@ -6481,6 +6723,11 @@ declare interface EnableLibraryPluginOptions {
 	 */
 	additionalApply?: () => void;
 }
+
+/**
+ * Validates and enables named wasm loading backends by applying the plugin
+ * implementations that provide their runtime support.
+ */
 declare class EnableWasmLoadingPlugin {
 	/**
 	 * Stores the wasm loading backend name that should be enabled for the
@@ -6587,6 +6834,11 @@ declare interface EntryDescription {
 	 */
 	filename?: string | TemplatePathFn<PathDataChunk>;
 
+	/**
+	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. Overrides `output.html` for this entry.
+	 */
+	html?: boolean;
+
 	/**
 	 * Module(s) that are loaded upon startup.
 	 */
@@ -6616,6 +6868,11 @@ declare interface EntryDescription {
 	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
 	 */
 	wasmLoading?: string | false;
+
+	/**
+	 * Mark this entry as a worker so its output file uses 'output.workerChunkFilename'.
+	 */
+	worker?: boolean;
 }
 
 /**
@@ -6647,6 +6904,11 @@ declare interface EntryDescriptionNormalized {
 	 */
 	filename?: string | TemplatePathFn<PathDataChunk>;
 
+	/**
+	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. Overrides `output.html` for this entry.
+	 */
+	html?: boolean;
+
 	/**
 	 * Module(s) that are loaded upon startup. The last one is exported.
 	 */
@@ -6676,6 +6938,11 @@ declare interface EntryDescriptionNormalized {
 	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
 	 */
 	wasmLoading?: string | false;
+
+	/**
+	 * Mark this entry as a worker so its output file uses 'output.workerChunkFilename'.
+	 */
+	worker?: boolean;
 }
 type EntryItem = string | string[];
 type EntryLibIndex =
@@ -6700,6 +6967,7 @@ declare class EntryOptionPlugin {
 	 * Applies the plugin by registering its hooks on the compiler.
 	 */
 	apply(compiler: Compiler): void;
+	static getHooks(compiler: Compiler): EntryOptionPluginHooks;
 
 	/**
 	 * Apply entry option.
@@ -6719,6 +6987,15 @@ declare class EntryOptionPlugin {
 		desc: EntryDescriptionNormalized
 	): EntryOptions;
 }
+declare interface EntryOptionPluginHooks {
+	/**
+	 * transform an entry into a different request (e.g. wrap a non-HTML entry in a synthetic HTML module); return `undefined` to keep the default behavior
+	 */
+	entry: SyncBailHook<
+		[string, string, EntryDescriptionNormalized],
+		undefined | string
+	>;
+}
 type EntryOptions = { name?: string } & Omit<
 	EntryDescriptionNormalized,
 	"import"
@@ -6745,6 +7022,11 @@ declare class EntryPlugin {
 		options: string | EntryOptions
 	): EntryDependency;
 }
+declare interface EntryScriptInfo {
+	request: string;
+	entryName: string;
+	type: "script" | "stylesheet" | "script-module" | "modulepreload";
+}
 type EntryStatic = string | EntryObject | string[];
 
 /**
@@ -6758,6 +7040,13 @@ declare interface EntryTypesIndex {
 	timestamp: number;
 	accuracy: number;
 }
+
+/**
+ * Entrypoint serves as an encapsulation primitive for chunks that are
+ * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
+ * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
+ * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
+ */
 declare abstract class Entrypoint extends ChunkGroup {
 	/**
 	 * Sets the runtimeChunk for an entrypoint.
@@ -6847,11 +7136,26 @@ declare interface Environment {
 	 */
 	globalThis?: boolean;
 
+	/**
+	 * The environment supports 'Object.hasOwn'.
+	 */
+	hasOwn?: boolean;
+
 	/**
 	 * The environment supports `import.meta.dirname` and `import.meta.filename`.
 	 */
 	importMetaDirnameAndFilename?: boolean;
 
+	/**
+	 * The environment supports let for variable declarations.
+	 */
+	let?: boolean;
+
+	/**
+	 * The environment supports logical assignment operators ('a ||= b', 'a &&= b', 'a ??= b').
+	 */
+	logicalAssignment?: boolean;
+
 	/**
 	 * The environment supports object method shorthand ('{ module() {} }').
 	 */
@@ -6862,6 +7166,11 @@ declare interface Environment {
 	 */
 	module?: boolean;
 
+	/**
+	 * The environment supports `process.getBuiltinModule()` to synchronously load Node.js core modules.
+	 */
+	nodeBuiltinModuleGetter?: boolean;
+
 	/**
 	 * The environment supports `node:` prefix for Node.js core modules.
 	 */
@@ -6872,6 +7181,16 @@ declare interface Environment {
 	 */
 	optionalChaining?: boolean;
 
+	/**
+	 * The environment supports spread and rest in array/object literals and calls ('{ ...obj }', 'fn(...args)').
+	 */
+	spread?: boolean;
+
+	/**
+	 * The environment supports 'Symbol' (and well-known symbols like 'Symbol.toStringTag').
+	 */
+	symbol?: boolean;
+
 	/**
 	 * The environment supports template literals.
 	 */
@@ -7059,7 +7378,7 @@ declare interface Experiments {
 	futureDefaults?: boolean;
 
 	/**
-	 * Enable experimental HTML support. This flag does not by itself make `.html` files usable directly as entry points without additional HTML handling.
+	 * Enable HTML entry support. Treats `.html` files as a first-class module type so they can be used directly as entry points.
 	 * @experimental
 	 */
 	html?: boolean;
@@ -7208,7 +7527,28 @@ declare abstract class ExportInfo {
 	canMangleUse?: boolean;
 	exportsInfoOwned: boolean;
 	exportsInfo?: ExportsInfo;
+
+	/**
+	 * defined: the export binds to a small primitive constant and may be inlined
+	 * undefined: not an inlined constant export
+	 */
+	canInlineProvide?: InlinedValue;
+
+	/**
+	 * true: at least one consumer accepts inlining, none rejected
+	 * false: at least one consumer rejected inlining
+	 * undefined: collecting; no consumer has decided yet
+	 */
+	canInlineUse?: boolean;
+
+	/**
+	 * Only specific export info can be pure, so other_export_info.pure is always undefined.
+	 * true: calling the export has no observable side effects
+	 * undefined: it was not determined whether the export is pure
+	 */
+	pureProvide?: boolean;
 	get canMangle(): boolean;
+	canInline(): undefined | InlinedValue;
 
 	/**
 	 * Sets used in unknown way.
@@ -7257,12 +7597,12 @@ declare abstract class ExportInfo {
 	getUsed(runtime: RuntimeSpec): UsageStateType;
 
 	/**
-	 * Returns used name.
+	 * Returns used name. May return InlinedUsedName when the export is inlined to a primitive.
 	 */
 	getUsedName(
 		fallbackName: undefined | string,
 		runtime: RuntimeSpec
-	): string | false;
+	): string | false | InlinedUsedName;
 
 	/**
 	 * Checks whether this export info has used name.
@@ -7272,7 +7612,7 @@ declare abstract class ExportInfo {
 	/**
 	 * Updates used name using the provided name.
 	 */
-	setUsedName(name: string): void;
+	setUsedName(name: string | InlinedUsedName): void;
 
 	/**
 	 * Gets terminal binding.
@@ -7307,7 +7647,7 @@ declare abstract class ExportInfo {
 		resolveTargetFilter: (target: TargetItemWithConnection) => boolean,
 		updateOriginalConnection?: (
 			target: TargetItemWithConnection
-		) => ModuleGraphConnection
+		) => undefined | ModuleGraphConnection
 	): undefined | TargetItemWithConnection;
 
 	/**
@@ -7371,6 +7711,11 @@ declare interface ExportSpec {
 	 */
 	terminalBinding?: boolean;
 
+	/**
+	 * calling this export has no observable side effects
+	 */
+	isPure?: boolean;
+
 	/**
 	 * nested exports
 	 */
@@ -7395,9 +7740,19 @@ declare interface ExportSpec {
 	 * export is not visible, because another export blends over it
 	 */
 	hidden?: boolean;
+
+	/**
+	 * when set: the export binds to a small primitive constant eligible for inlining
+	 */
+	inlined?: InlinedValue;
 }
 type ExportedVariableInfo = string | VariableInfo | ScopeInfo;
 declare abstract class ExportsInfo {
+	/**
+	 * Records that an owned export got an inlined used name.
+	 */
+	markInlinedExports(): void;
+
 	/**
 	 * Gets owned exports.
 	 */
@@ -7536,6 +7891,12 @@ declare abstract class ExportsInfo {
 	 */
 	getUsedName(name: string | string[], runtime: RuntimeSpec): UsedName;
 
+	/**
+	 * Checks whether `getUsedName(name, runtime)` would return an `InlinedUsedName`,
+	 * without allocating intermediate used-name arrays (hot path for connection conditions).
+	 */
+	hasInlinedUsedName(name: string[], runtime: RuntimeSpec): boolean;
+
 	/**
 	 * Updates the hash with the data contributed by this instance.
 	 */
@@ -7587,6 +7948,11 @@ declare interface ExportsSpec {
 	 */
 	terminalBinding?: boolean;
 
+	/**
+	 * calling these exports has no observable side effects
+	 */
+	isPure?: boolean;
+
 	/**
 	 * module on which the result depends on
 	 */
@@ -7594,9 +7960,9 @@ declare interface ExportsSpec {
 }
 type ExportsType =
 	| "namespace"
+	| "dynamic"
 	| "default-only"
-	| "default-with-named"
-	| "dynamic";
+	| "default-with-named";
 type Exposes = (string | ExposesObject)[] | ExposesObject;
 
 /**
@@ -7777,7 +8143,8 @@ declare class ExternalModule extends Module {
 	static getCompilationHooks(compilation: Compilation): ExternalModuleHooks;
 	static ModuleExternalInitFragment: typeof ModuleExternalInitFragment;
 	static getExternalModuleNodeCommonjsInitFragment: (
-		runtimeTemplate: RuntimeTemplate
+		runtimeTemplate: RuntimeTemplate,
+		universal?: boolean
 	) => InitFragment<ChunkRenderContextJavascriptModulesPlugin>;
 
 	/**
@@ -7786,6 +8153,9 @@ declare class ExternalModule extends Module {
 	 */
 	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
 }
+type ExternalModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownExternalModuleBuildInfo;
 declare interface ExternalModuleHooks {
 	chunkCondition: SyncBailHook<[Chunk, Compilation], boolean>;
 }
@@ -7801,6 +8171,11 @@ declare interface ExternalModuleInfo {
 	 */
 	name?: string;
 
+	/**
+	 * decoupled namespace object that keeps original export names when the exports are mangled
+	 */
+	escapeNamespaceObjectName?: string;
+
 	/**
 	 * deferred module.exports / harmony namespace object
 	 */
@@ -7850,6 +8225,24 @@ declare interface ExternalModuleInfo {
 	 * runtime namespace object that detects "__esModule"
 	 */
 	interopDefaultAccessName?: string;
+
+	/**
+	 * memoized getExportsType(strict=true)
+	 */
+	exportsTypeStrict?:
+		| "namespace"
+		| "dynamic"
+		| "default-only"
+		| "default-with-named";
+
+	/**
+	 * memoized getExportsType(strict=false)
+	 */
+	exportsTypeNonStrict?:
+		| "namespace"
+		| "dynamic"
+		| "default-only"
+		| "default-with-named";
 }
 type ExternalModuleRequest = string | string[] | RequestRecord;
 type Externals =
@@ -7940,6 +8333,16 @@ declare class ExternalsPlugin {
  * Enable presets of externals for specific targets.
  */
 declare interface ExternalsPresets {
+	/**
+	 * Treat bun built-in modules like 'bun', 'bun:sqlite' or 'bun:ffi' and node.js built-in modules as external and load them via import when used (for the Bun runtime).
+	 */
+	bun?: boolean;
+
+	/**
+	 * Treat node.js built-in modules like fs, path or vm as external and load them via the required 'node:' specifier when used (for the Deno runtime).
+	 */
+	deno?: boolean;
+
 	/**
 	 * Treat common electron built-in modules in main and preload context like 'electron', 'ipc' or 'shell' as external and load them via require() when used.
 	 */
@@ -8057,6 +8460,11 @@ declare interface FallbackCacheGroup {
 	maxInitialSize: SplitChunksSizes;
 	automaticNameDelimiter: string;
 }
+
+/**
+ * Enables asynchronous WebAssembly loading through `fetch` for environments
+ * that can instantiate fetched binaries at runtime.
+ */
 declare class FetchCompileAsyncWasmPlugin {
 	constructor();
 
@@ -8066,6 +8474,11 @@ declare class FetchCompileAsyncWasmPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+
+/**
+ * Enables synchronous WebAssembly chunk loading that fetches `.wasm` files and
+ * compiles them in browser-like environments.
+ */
 declare class FetchCompileWasmPlugin {
 	/**
 	 * Stores options that affect generated synchronous WebAssembly runtime code.
@@ -8232,6 +8645,10 @@ declare interface FileSystem {
 	 */
 	realpath?: RealPathTypes;
 }
+
+/**
+ * Used to access information about the filesystem in a cached way
+ */
 declare abstract class FileSystemInfo {
 	fs: InputFileSystem;
 	logger?: WebpackLogger;
@@ -8458,6 +8875,7 @@ declare class Generator {
 	 * Returns the source types available for this module.
 	 */
 	getTypes(module: NormalModule): ReadonlySet<string>;
+	getTypesDependOnIncomingConnections(): boolean;
 
 	/**
 	 * Returns the estimated size for the requested source type.
@@ -8592,7 +9010,8 @@ declare class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			| string
 			| false
 			| ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string),
-		allChunks: boolean
+		allChunks: boolean,
+		usesFullHashDigest?: boolean
 	);
 	contentType: string;
 	global: string;
@@ -8663,6 +9082,10 @@ declare interface GroupOptionsSmartGrouping {
 	force?: boolean;
 	targetGroupCount?: number;
 }
+declare interface GuardCollection {
+	consequent?: object;
+	alternate?: object;
+}
 declare interface HMRJavascriptParserHooks {
 	hotAcceptCallback: SyncBailHook<
 		[
@@ -8841,8 +9264,20 @@ declare class HarmonyImportDependency extends ModuleDependency {
 		members: string[],
 		membersOptionals: boolean[]
 	) => string[];
+
+	/**
+	 * Compares two dependencies by source location for sorting a module's
+	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
+	 * its result, so comparing through it would retain a location object on every
+	 * sorted dependency). These dependencies always carry a real source position,
+	 * so only start (line, column) and the within-statement index are compared; a
+	 * dependency without an index sorts after one that has an index at the same
+	 * position.
+	 */
+	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];
 
 	/**
 	 * Returns true if the dependency is a low priority dependency.
@@ -8854,6 +9289,10 @@ declare class HarmonyImportDependency extends ModuleDependency {
 	 */
 	static canConcatenate(dependency: Dependency): boolean;
 	static TRANSITIVE: symbol;
+	static LAZY_UNTIL_LOCAL: "local";
+	static LAZY_UNTIL_ID: "id";
+	static LAZY_UNTIL_FALLBACK: "*";
+	static LAZY_UNTIL_REQUEST: "@";
 }
 declare class HarmonyImportDependencyTemplate extends DependencyTemplate {
 	constructor();
@@ -8875,9 +9314,6 @@ declare interface HarmonySettings {
 	attributes?: ImportAttributes;
 	phase: ImportPhaseType;
 }
-declare interface HarmonySpecifierGuards {
-	guards?: AppendOnlyStackedSet<string>;
-}
 declare abstract class HarmonyStarExportsList {
 	dependencies: HarmonyExportImportedSpecifierDependency[];
 
@@ -8890,12 +9326,12 @@ declare abstract class HarmonyStarExportsList {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContext): void;
+	serialize(__0: StarListSerializerContext): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContext): void;
+	deserialize(__0: StarListDeserializerContext): void;
 }
 declare class Hash {
 	constructor();
@@ -8980,6 +9416,18 @@ declare interface HashedModuleIdsPluginOptions {
 	 */
 	hashFunction?: string | typeof Hash;
 }
+type Head<T extends ReadonlyArray<any>> = T extends readonly [infer H, ...any[]]
+	? H
+	: T extends readonly []
+		? any
+		: T extends (infer E)[]
+			? E
+			: never;
+
+/**
+ * Base class for runtime modules that only emit helper functions and do not
+ * need special staging or attachment behavior beyond `RuntimeModule`.
+ */
 declare abstract class HelperRuntimeModule extends RuntimeModule {}
 declare class HotModuleReplacementPlugin {
 	constructor();
@@ -9054,16 +9502,117 @@ declare abstract class HtmlGenerator extends Generator {
  */
 declare interface HtmlGeneratorOptions {
 	/**
-	 * Emit the parsed and URL-rewritten HTML as a standalone `.html` output file alongside the module's JavaScript export. When unset, extraction defaults to `true` for HTML modules used as compilation entries (HTML entry points) and `false` for HTML modules imported from JavaScript. Filenames follow `output.htmlFilename` / `output.htmlChunkFilename`.
+	 * Emit the parsed and URL-rewritten HTML as a standalone `.html` output file alongside the module's JavaScript export. `true` always emits the file; `false` never does; `"inline"` exposes the processed HTML for inline write-back (e.g. `<iframe srcdoc>`) without emitting a standalone file. When unset, extraction defaults to `true` for HTML modules used as compilation entries (HTML entry points) and `false` for HTML modules imported from JavaScript. Filenames follow `output.htmlFilename` / `output.htmlChunkFilename`.
 	 */
-	extract?: boolean;
+	extract?: boolean | "inline";
 }
+type HtmlModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownNormalModuleBuildInfo &
+	KnownHtmlModuleBuildInfo;
 declare abstract class HtmlParser extends ParserClass {
 	magicCommentContext: ContextImport;
-	hashFunction?: string | typeof Hash;
-	context?: string;
-	outputModule?: boolean;
-	css?: boolean;
+	template?: (source: string, context: HtmlTemplateContext) => string;
+	sourcesByTag: Record<string, Record<string, SourceItem>>;
+
+	/**
+	 * Runs the `template` option over the source and returns the transformed
+	 * html. Called from HtmlModulesPlugin's `processResult`, where the return
+	 * value becomes the module's stored source so the parser (which records
+	 * dependency offsets against it) and the generator (which renders from
+	 * `module.originalSource()`) stay in agreement.
+	 */
+	applyTemplate(source: string | Buffer, module: NormalModule): string | Buffer;
+}
+
+/**
+ * Parser options for html modules.
+ */
+declare interface HtmlParserOptions {
+	/**
+	 * Configure extraction of URL-like attribute values (e.g. `<img src>`, `<link href>`, `<script src>`) as webpack dependencies. `true` (default) uses the built-in source list; `false` disables extraction entirely so attributes are left untouched and `<script src>` / `<link rel="modulepreload">` / `<link rel="stylesheet">` no longer become compilation entries; an array lets you customize which `tag`/`attribute` pairs are treated as URLs and how they are bundled. Use the string `"..."` inside the array to inline the defaults. Inline `<script>` and `<style>` bodies are always processed. Use `webpackIgnore` comments or `IgnorePlugin` to skip individual URLs.
+	 */
+	sources?:
+		| boolean
+		| (
+				| "..."
+				| {
+						/**
+						 * Attribute name whose value is treated as a URL.
+						 */
+						attribute: string;
+						/**
+						 * Called with the element's decoded attribute map and the decoded attribute value; return false to skip this source entry for that element.
+						 */
+						filter?: (
+							attributes: Map<string, string>,
+							value: string
+						) => boolean;
+						/**
+						 * Tag name to match. Omit to match any tag.
+						 */
+						tag?: string;
+						/**
+						 * How the attribute value should be parsed and bundled. `src` extracts a single URL as a plain asset; `srcset` parses a `srcset`-style list of candidate URLs as plain assets; `css-url` extracts `url(...)` references from a CSS value (like an SVG presentation attribute such as `fill`) as plain assets; `script` and `script-module` emit a classic / ES-module chunk entry like `<script src>` and `<script type="module" src>`; `stylesheet` emits a CSS chunk entry like `<link rel="stylesheet">`; `stylesheet-style` treats the attribute value as a full stylesheet (like a `<style>` body) and `stylesheet-style-attribute` as a CSS block's contents (a declaration list, like a `style` attribute) — both bundle it through the CSS pipeline and replace the attribute's content with the processed CSS at render time; `srcdoc` treats the attribute value as an entity-encoded HTML document (like `<iframe srcdoc>`), bundling it through the HTML pipeline and replacing the attribute's content with the processed HTML at render time.
+						 */
+						type:
+							| "script"
+							| "css-url"
+							| "stylesheet"
+							| "script-module"
+							| "src"
+							| "srcset"
+							| "stylesheet-style"
+							| "stylesheet-style-attribute"
+							| "srcdoc";
+				  }
+		  )[];
+
+	/**
+	 * Transform the raw source before the html parser extracts dependencies. Receives the source string and a context (`{ module, resource }`) and must return the html string to parse. Useful for compiling a templating language (Handlebars, EJS, Eta, …) to html so that URLs the template emits are still picked up as webpack dependencies. Runs synchronously.
+	 */
+	template?: (source: string, context: HtmlTemplateContext) => string;
+}
+declare interface HtmlTemplateContext {
+	/**
+	 * the html module being transformed
+	 */
+	module: Module;
+
+	/**
+	 * absolute path of the module's resource
+	 */
+	resource: string;
+
+	/**
+	 * register a file (e.g. a template partial) as a build dependency so editing it triggers a rebuild
+	 */
+	addDependency: (dependency: string) => void;
+
+	/**
+	 * register a directory as a build dependency
+	 */
+	addContextDependency: (dependency: string) => void;
+
+	/**
+	 * register a not-yet-existing path as a build dependency so creating it triggers a rebuild
+	 */
+	addMissingDependency: (dependency: string) => void;
+
+	/**
+	 * register a build dependency (e.g. a template engine config) so changing it invalidates the cache
+	 */
+	addBuildDependency: (dependency: string) => void;
+
+	/**
+	 * report a non-fatal warning on the module
+	 */
+	emitWarning: (warning: string | Error) => void;
+
+	/**
+	 * report an error on the module
+	 */
+	emitError: (error: string | Error) => void;
 }
 
 /**
@@ -9580,6 +10129,10 @@ type InfrastructureLoggingNormalizedWithDefaults = InfrastructureLogging & {
 	colors: NonNullable<undefined | boolean>;
 	appendOnly: NonNullable<undefined | boolean>;
 };
+
+/**
+ * Represents InitFragment.
+ */
 declare class InitFragment<GenerateContext> {
 	/**
 	 * Creates an instance of InitFragment.
@@ -9610,12 +10163,12 @@ declare class InitFragment<GenerateContext> {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(context: ObjectSerializerContext): void;
+	serialize(context: ObjectSerializerContextObjectMiddlewareObject_5): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(context: ObjectDeserializerContext): void;
+	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_4): void;
 
 	/**
 	 * Adds the provided source to the init fragment.
@@ -9633,6 +10186,54 @@ declare class InitFragment<GenerateContext> {
 	static STAGE_ASYNC_DEPENDENCIES: number;
 	static STAGE_ASYNC_HARMONY_IMPORTS: number;
 }
+declare abstract class InlinedUsedName {
+	value: InlinedValue;
+	suffix: string[];
+	render(comment: string): string;
+}
+declare abstract class InlinedValue {
+	kind: InlinedValueKind;
+	value?: null | string | number | boolean;
+	renderLiteral(): string;
+	render(comment: string): string;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
+}
+type InlinedValueKind = "string" | "number" | "boolean" | "undefined" | "null";
+declare interface InnerGraphUtils {
+	enable: (parserState: ParserState) => void;
+	bailout: (parserState: ParserState) => void;
+	isEnabled: (parserState: ParserState) => boolean;
+	addUsage: (
+		parserState: ParserState,
+		symbol: null | TopLevelSymbol,
+		usage: Usage
+	) => void;
+	onUsage: (
+		parserState: ParserState,
+		onUsageCallback: (
+			value: undefined | boolean | Set<string>,
+			module: Module
+		) => void
+	) => void;
+	setTopLevelSymbol: (
+		parserState: ParserState,
+		symbol?: TopLevelSymbol
+	) => void;
+	getTopLevelSymbol: (parserState: ParserState) => void | TopLevelSymbol;
+	tagTopLevelSymbol: (
+		parser: JavascriptParser,
+		name: string,
+		pure?: boolean | ((compilation: Compilation, module: Module) => boolean)
+	) => undefined | TopLevelSymbol;
+	addVariableUsage: (
+		parser: JavascriptParser,
+		name: string,
+		usage: Usage
+	) => void;
+	inferDependencyUsage: (module: Module) => void;
+	release: (module: Module) => void;
+}
 
 /**
  * Returns location of targetPath relative to rootPath.
@@ -9658,7 +10259,10 @@ declare interface InputFileSystem {
 		) => void
 	) => void;
 	readJsonSync?: (pathOrFileDescriptor: PathOrFileDescriptorFs) => JsonObjectFs;
-	purge?: (value?: string | string[] | Set<string>) => void;
+	purge?: (
+		value?: string | string[] | Set<string>,
+		options?: { exact?: boolean }
+	) => void;
 	join?: (path1: string, path2: string) => string;
 	relative?: (from: string, to: string) => string;
 	dirname?: (dirname: string) => string;
@@ -9795,6 +10399,13 @@ declare abstract class JavascriptGenerator extends Generator {
 		generateContext: GenerateContext
 	): null | Source;
 }
+type JavascriptModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownNormalModuleBuildInfo &
+	KnownJavascriptModuleBuildInfo;
+type JavascriptModuleBuildMeta = KnownBuildMeta &
+	Record<string, any> &
+	KnownJavascriptModuleBuildMeta;
 declare class JavascriptModulesPlugin {
 	constructor(options?: object);
 	options: object;
@@ -10096,10 +10707,7 @@ declare class JavascriptParser extends ParserClass {
 			boolean | void
 		>;
 		statementIf: SyncBailHook<[IfStatement], boolean | void>;
-		collectGuards: SyncBailHook<
-			[Expression],
-			void | ((walk: () => void) => void)
-		>;
+		collectGuards: SyncBailHook<[Expression], void | GuardCollection>;
 		classExtendsExpression: SyncBailHook<
 			[
 				Expression,
@@ -10396,8 +11004,7 @@ declare class JavascriptParser extends ParserClass {
 		| HarmonySettings
 		| ImportSettings
 		| CommonJsImportSettings
-		| CompatibilitySettings
-		| HarmonySpecifierGuards;
+		| CompatibilitySettings;
 	magicCommentContext: ContextImport;
 
 	/**
@@ -10717,6 +11324,12 @@ declare class JavascriptParser extends ParserClass {
 	 */
 	preWalkIfStatement(statement: IfStatement): void;
 
+	/**
+	 * Walks a conditional branch with its guard frame (if any) pushed onto the
+	 * parser-state guard stack for the duration of the branch body.
+	 */
+	walkGuardedBranch(frame: undefined | null | object, walk: () => void): void;
+
 	/**
 	 * Processes the provided statement.
 	 */
@@ -11640,8 +12253,7 @@ declare class JavascriptParser extends ParserClass {
 		| HarmonySettings
 		| ImportSettings
 		| CommonJsImportSettings
-		| CompatibilitySettings
-		| HarmonySpecifierGuards;
+		| CompatibilitySettings;
 
 	/**
 	 * Processes the provided name.
@@ -11655,8 +12267,7 @@ declare class JavascriptParser extends ParserClass {
 			| HarmonySettings
 			| ImportSettings
 			| CommonJsImportSettings
-			| CompatibilitySettings
-			| HarmonySpecifierGuards,
+			| CompatibilitySettings,
 		flags?: 0 | 1 | 2 | 4
 	): void;
 
@@ -11698,6 +12309,72 @@ declare class JavascriptParser extends ParserClass {
 		errors: null | (Error & { comment: CommentJavascriptParser })[];
 	};
 
+	/**
+	 * Finds the root object of a member expression chain without allocating the
+	 * member arrays. The traversal/break logic must stay in sync with
+	 * `extractMemberExpressionChain`; it lets `getMemberExpressionInfo` reject
+	 * unrecognized roots (~77% of calls) before paying for the arrays.
+	 */
+	getMemberExpressionRoot(
+		expression:
+			| ImportExpressionImport
+			| UnaryExpression
+			| ArrayExpression
+			| ArrowFunctionExpression
+			| AssignmentExpression
+			| AwaitExpression
+			| BinaryExpression
+			| SimpleCallExpression
+			| NewExpression
+			| ChainExpression
+			| ClassExpression
+			| ConditionalExpression
+			| FunctionExpression
+			| Identifier
+			| SimpleLiteral
+			| RegExpLiteral
+			| BigIntLiteral
+			| LogicalExpression
+			| MemberExpression
+			| MetaProperty
+			| ObjectExpression
+			| SequenceExpression
+			| TaggedTemplateExpression
+			| TemplateLiteral
+			| ThisExpression
+			| UpdateExpression
+			| YieldExpression
+			| Super
+	):
+		| ImportExpressionImport
+		| UnaryExpression
+		| ArrayExpression
+		| ArrowFunctionExpression
+		| AssignmentExpression
+		| AwaitExpression
+		| BinaryExpression
+		| SimpleCallExpression
+		| NewExpression
+		| ChainExpression
+		| ClassExpression
+		| ConditionalExpression
+		| FunctionExpression
+		| Identifier
+		| SimpleLiteral
+		| RegExpLiteral
+		| BigIntLiteral
+		| LogicalExpression
+		| MemberExpression
+		| MetaProperty
+		| ObjectExpression
+		| SequenceExpression
+		| TaggedTemplateExpression
+		| TemplateLiteral
+		| ThisExpression
+		| UpdateExpression
+		| YieldExpression
+		| Super;
+
 	/**
 	 * Extract member expression chain.
 	 */
@@ -11901,7 +12578,7 @@ declare interface JavascriptParserOptions {
 	/**
 	 * Specifies global mode for dynamic import.
 	 */
-	dynamicImportMode?: "weak" | "eager" | "lazy" | "lazy-once";
+	dynamicImportMode?: "eager" | "weak" | "lazy" | "lazy-once";
 
 	/**
 	 * Specifies global prefetch for dynamic import.
@@ -11983,6 +12660,11 @@ declare interface JavascriptParserOptions {
 	 */
 	parse?: (code: string, options: ParseOptions) => ParseResult;
 
+	/**
+	 * Mark the listed top-level function names for pure-function-based tree shaking.
+	 */
+	pureFunctions?: string[];
+
 	/**
 	 * Specifies the behavior of invalid export names in "export ... from ...". This might be useful to disable during the migration from "export ... from ..." to "export type ... from ..." when reexporting types in TypeScript.
 	 */
@@ -12134,6 +12816,10 @@ declare interface JsonGeneratorOptions {
 	 */
 	JSONParse?: boolean;
 }
+type JsonModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownNormalModuleBuildInfo &
+	KnownJsonModuleBuildInfo;
 declare interface JsonObjectFs {
 	[index: string]:
 		| undefined
@@ -12276,6 +12962,11 @@ declare interface KnownAssetInfo {
 	 */
 	contenthash?: string | string[];
 
+	/**
+	 * maps a `[contenthash:<digest>]` value to its digest, so `RealContentHashPlugin` re-encodes the recomputed hash in it
+	 */
+	contenthashDigest?: Record<string, string>;
+
 	/**
 	 * when asset was created from a source file (potentially transformed), the original filename relative to compilation context
 	 */
@@ -12311,152 +13002,97 @@ declare interface KnownAssetInfo {
 	 */
 	related?: Record<string, null | string | string[]>;
 }
+declare interface KnownAssetModuleBuildInfo {
+	/**
+	 * whether the asset is inlined as a data url
+	 */
+	dataUrl?: boolean;
+	filename?: string;
+	assetInfo?: AssetInfo;
+	fullContentHash?: string;
+}
 declare interface KnownBuildInfo {
 	cacheable?: boolean;
-	parsed?: boolean;
 	strict?: boolean;
-
-	/**
-	 * using in AMD
-	 */
 	moduleArgument?: string;
-
-	/**
-	 * using in AMD
-	 */
 	exportsArgument?: string;
 
 	/**
-	 * using in CommonJs
+	 * assets added by loaders or plugins
 	 */
-	moduleConcatenationBailout?: string;
+	assets?: Record<string, Source>;
+	assetsInfo?: Map<string, undefined | AssetInfo>;
 
 	/**
-	 * using in APIPlugin
+	 * top level declaration names
 	 */
-	needCreateRequire?: boolean;
+	topLevelDeclarations?: Set<string>;
 
 	/**
-	 * using in HttpUriPlugin
+	 * true when the module is part of a circular dependency chain
 	 */
-	resourceIntegrity?: string;
+	isCircular?: boolean;
+}
+declare interface KnownBuildMeta {
+	exportsType?: "default" | "namespace" | "flagged" | "dynamic";
+	defaultObject?: false | "redirect" | "redirect-warn";
+	async?: boolean;
+	sideEffectFree?: boolean;
 
 	/**
-	 * using in NormalModule
+	 * using in ModuleLibraryPlugin
 	 */
-	fileDependencies?: LazySet<string>;
+	exportsFinalNameByRuntime?: Map<string, Record<string, string>>;
 
 	/**
-	 * using in NormalModule
+	 * using in ModuleLibraryPlugin
 	 */
+	exportsSourceByRuntime?: Map<string, string>;
+}
+declare interface KnownConcatenatedModuleBuildInfo {
+	fileDependencies?: LazySet<string>;
 	contextDependencies?: LazySet<string>;
-
-	/**
-	 * using in NormalModule
-	 */
 	missingDependencies?: LazySet<string>;
 
 	/**
-	 * using in NormalModule
+	 * collected from the inner modules
 	 */
-	buildDependencies?: LazySet<string>;
-
-	/**
-	 * using in NormalModule
-	 */
-	valueDependencies?: Map<string, ValueCacheVersion>;
-
-	/**
-	 * using in NormalModule
-	 */
-	assets?: Record<string, Source>;
-
-	/**
-	 * using in NormalModule
-	 */
-	assetsInfo?: Map<string, undefined | AssetInfo>;
+	needCreateRequire?: boolean;
 
 	/**
-	 * using in NormalModule
+	 * taken over from the root module
 	 */
-	hash?: string;
-
+	inlineExports?: boolean;
+}
+declare interface KnownContext {
 	/**
-	 * using in ContextModule
+	 * environments
 	 */
+	environments?: string[];
+}
+declare interface KnownContextModuleBuildInfo {
 	snapshot?: null | Snapshot;
-
-	/**
-	 * for assets modules
-	 */
-	fullContentHash?: string;
-
-	/**
-	 * for assets modules
-	 */
-	filename?: string;
-
-	/**
-	 * for assets modules
-	 */
-	dataUrl?: boolean;
-
-	/**
-	 * for assets modules
-	 */
-	assetInfo?: AssetInfo;
-
-	/**
-	 * for external modules
-	 */
-	javascriptModule?: boolean;
-
-	/**
-	 * for lazy compilation modules
-	 */
-	active?: boolean;
-
-	/**
-	 * for css modules
-	 */
+}
+declare interface KnownCreateStatsOptionsContext {
+	forToString?: boolean;
+}
+declare interface KnownCssModuleBuildInfo {
 	cssData?: CssData;
 
 	/**
-	 * for css modules (charset at-rule)
+	 * charset at-rule
 	 */
 	charset?: string;
-
-	/**
-	 * for json modules
-	 */
-	jsonData?: JsonData;
-
-	/**
-	 * top level declaration names
-	 */
-	topLevelDeclarations?: Set<string>;
 }
-declare interface KnownBuildMeta {
-	exportsType?: "namespace" | "dynamic" | "default" | "flagged";
-	defaultObject?: false | "redirect" | "redirect-warn";
-	strictHarmonyModule?: boolean;
-	treatAsCommonJs?: boolean;
-	async?: boolean;
-	sideEffectFree?: boolean;
+declare interface KnownCssModuleBuildMeta {
 	isCssModule?: boolean;
 	needIdInConcatenation?: boolean;
-	jsIncompatibleExports?: Record<string, string>;
-	exportsFinalNameByRuntime?: Map<string, Record<string, string>>;
-	exportsSourceByRuntime?: Map<string, string>;
 }
-declare interface KnownContext {
+declare interface KnownExternalModuleBuildInfo {
 	/**
-	 * environments
+	 * true when emitting an ESM external (`output.module`)
 	 */
-	environments?: string[];
-}
-declare interface KnownCreateStatsOptionsContext {
-	forToString?: boolean;
+	javascriptModule?: boolean;
 }
 declare interface KnownHooks {
 	/**
@@ -12490,16 +13126,65 @@ declare interface KnownHooks {
 	 */
 	result: AsyncSeriesHook<[ResolveRequest, ResolveContext]>;
 }
+declare interface KnownHtmlModuleBuildInfo {
+	/**
+	 * entries collected from the document, grouped by kind
+	 */
+	htmlEntryScripts?: Record<string, EntryScriptInfo[]>;
+}
+declare interface KnownJavascriptModuleBuildInfo {
+	/**
+	 * using in CommonJs
+	 */
+	moduleConcatenationBailout?: string;
+
+	/**
+	 * using in APIPlugin
+	 */
+	needCreateRequire?: boolean;
+
+	/**
+	 * names of locally declared functions known to be free of side effects
+	 */
+	pureFunctions?: Set<string>;
+
+	/**
+	 * whether this module was parsed with `optimization.inlineExports` enabled (gates inlining of its exports)
+	 */
+	inlineExports?: boolean;
+}
+declare interface KnownJavascriptModuleBuildMeta {
+	strictHarmonyModule?: boolean;
+	treatAsCommonJs?: boolean;
+}
 declare interface KnownJavascriptParserState {
 	harmonyNamedExports?: Set<string>;
 	harmonyStarExports?: HarmonyStarExportsList;
 	lastHarmonyImportOrder?: number;
 	localModules?: LocalModule[];
 }
+declare interface KnownJsonModuleBuildInfo {
+	jsonData?: JsonData;
+}
 declare interface KnownMeta {
 	importVarMap?: Map<Module, string>;
 	deferredImportVarMap?: Map<Module, string>;
 }
+declare interface KnownNormalModuleBuildInfo {
+	parsed?: boolean;
+	hash?: string;
+	fileDependencies?: LazySet<string>;
+	contextDependencies?: LazySet<string>;
+	missingDependencies?: LazySet<string>;
+	buildDependencies?: LazySet<string>;
+	valueDependencies?: Map<string, ValueCacheVersion>;
+	snapshot?: null | Snapshot;
+
+	/**
+	 * using in HttpUriPlugin
+	 */
+	resourceIntegrity?: string;
+}
 declare interface KnownNormalizedStatsOptions {
 	context: string;
 	requestShortener: RequestShortener;
@@ -12869,6 +13554,9 @@ declare interface KnownStatsProfile {
 	factory: number;
 	dependencies: number;
 }
+declare interface KnownSyncWasmModuleBuildMeta {
+	jsIncompatibleExports?: Record<string, string>;
+}
 declare interface KnownUnsafeCacheData {
 	/**
 	 * factory meta
@@ -13039,6 +13727,12 @@ type LazyFunction<
 declare interface LazyOptions {
 	[index: string]: any;
 }
+
+/**
+ * Like Set but with an addAll method to eventually add items from another iterable.
+ * Access methods make sure that all delayed operations are executed.
+ * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
+ */
 declare class LazySet<T> {
 	/**
 	 * Seeds the set with an optional iterable while preparing internal queues for
@@ -13107,7 +13801,9 @@ declare class LazySet<T> {
 	 * Serializes the fully materialized set contents into webpack's object
 	 * serialization stream.
 	 */
-	serialize(__0: ObjectSerializerContext): void;
+	serialize(
+		__0: ObjectSerializerContextObjectMiddlewareObject_4<(number | T)[]>
+	): void;
 
 	/**
 	 * Returns the default iterator over values after forcing pending merges.
@@ -13117,7 +13813,9 @@ declare class LazySet<T> {
 	/**
 	 * Restores a `LazySet` from serialized item data.
 	 */
-	static deserialize<T>(__0: ObjectDeserializerContext): LazySet<T>;
+	static deserialize<T>(
+		__0: ObjectDeserializerContextObjectMiddlewareObject_3<(number | T)[]>
+	): LazySet<T>;
 }
 declare interface LibIdentOptions {
 	/**
@@ -13627,12 +14325,12 @@ declare abstract class LocalModule {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(context: ObjectSerializerContext): void;
+	serialize(context: ObjectSerializerContextObjectMiddlewareObject_2): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(context: ObjectDeserializerContext): void;
+	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_1): void;
 }
 declare interface LogEntry {
 	type:
@@ -13956,6 +14654,7 @@ declare interface MaybeMergeableInitFragment<GenerateContext> {
 		fragments: MaybeMergeableInitFragment<GenerateContext>[]
 	) => MaybeMergeableInitFragment<GenerateContext>[];
 }
+type MaybePromise<T> = T | Promise<T>;
 type Media = undefined | string;
 
 /**
@@ -14090,7 +14789,6 @@ declare class Module extends DependenciesBlock {
 	factoryMeta?: FactoryMeta;
 	useSourceMap: boolean;
 	useSimpleSourceMap: boolean;
-	hot: boolean;
 	buildMeta?: BuildMeta;
 	buildInfo?: BuildInfo;
 	presentationalDependencies?: Dependency[];
@@ -14362,6 +15060,11 @@ declare class Module extends DependenciesBlock {
 	 */
 	getSourceTypes(): ReadonlySet<string>;
 
+	/**
+	 * Freshly recomputed source types when they depend on incoming connections, for chunk-graph cache invalidation; undefined otherwise. #20800
+	 */
+	getReferencedSourceTypes(): undefined | ReadonlySet<string>;
+
 	/**
 	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
 	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
@@ -14519,9 +15222,22 @@ declare class ModuleDependency extends Dependency {
 	userRequest: string;
 	sourceOrder?: number;
 	range?: [number, number];
+	weak: boolean;
 	static Template: typeof DependencyTemplate;
+
+	/**
+	 * Compares two dependencies by source location for sorting a module's
+	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
+	 * its result, so comparing through it would retain a location object on every
+	 * sorted dependency). These dependencies always carry a real source position,
+	 * so only start (line, column) and the within-statement index are compared; a
+	 * dependency without an index sorts after one that has an index at the same
+	 * position.
+	 */
+	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];
 
 	/**
 	 * Returns true if the dependency is a low priority dependency.
@@ -14533,7 +15249,15 @@ declare class ModuleDependency extends Dependency {
 	 */
 	static canConcatenate(dependency: Dependency): boolean;
 	static TRANSITIVE: symbol;
+	static LAZY_UNTIL_LOCAL: "local";
+	static LAZY_UNTIL_ID: "id";
+	static LAZY_UNTIL_FALLBACK: "*";
+	static LAZY_UNTIL_REQUEST: "@";
 }
+
+/**
+ * Represents ModuleExternalInitFragment.
+ */
 declare class ModuleExternalInitFragment extends InitFragment<GenerateContext> {
 	/**
 	 * Creates an instance of ModuleExternalInitFragment.
@@ -15466,6 +16190,11 @@ declare interface ModuleReferenceOptions {
 	 */
 	deferredImport: boolean;
 
+	/**
+	 * true, when a whole-namespace reference may use a decoupled namespace object that keeps the original export names
+	 */
+	mangleableNamespace: boolean;
+
 	/**
 	 * if the position is ASI safe or unknown
 	 */
@@ -16002,6 +16731,7 @@ declare class NodeTargetPlugin {
 	 * Applies the plugin by registering its hooks on the compiler.
 	 */
 	apply(compiler: Compiler): void;
+	static builtins: (string | RegExp)[];
 }
 declare class NodeTemplatePlugin {
 	/**
@@ -16037,6 +16767,7 @@ declare class NormalModule extends Module {
 	matchResource?: string;
 	loaders: LoaderItem[];
 	extractSourceMap: boolean;
+	hot: boolean;
 	error: null | Error;
 	getResource(): null | string;
 
@@ -16081,7 +16812,9 @@ declare class NormalModule extends Module {
 	static getCompilationHooks(
 		compilation: Compilation
 	): NormalModuleCompilationHooks;
-	static deserialize(context: ObjectDeserializerContext): NormalModule;
+	static deserialize(
+		context: ObjectDeserializerContextObjectMiddlewareObject_4
+	): NormalModule;
 
 	/**
 	 * Gets source basic types.
@@ -16089,6 +16822,9 @@ declare class NormalModule extends Module {
 	 */
 	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
 }
+type NormalModuleBuildInfo = KnownBuildInfo &
+	Record<string, any> &
+	KnownNormalModuleBuildInfo;
 declare interface NormalModuleCompilationHooks {
 	loader: SyncHook<[AnyLoaderContext, NormalModule]>;
 	beforeLoaders: SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>;
@@ -16656,11 +17392,55 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
  */
 declare interface NormalModuleLoaderContext<OptionsType> {
 	version: number;
+
+	/**
+	 * Extracts and parses the options of the current loader.
+	 * Parses string options as JSON or a query string.
+	 * Extracts and parses the options of the current loader.
+	 * Parses string options as JSON or a query string, and optionally validates them against a provided schema.
+	 */
+
+	/**
+	 * Extracts and parses the options of the current loader.
+	 * Parses string options as JSON or a query string.
+	 */
 	getOptions(): OptionsType;
+
+	/**
+	 * Extracts and parses the options of the current loader.
+	 * Parses string options as JSON or a query string.
+	 * Extracts and parses the options of the current loader.
+	 * Parses string options as JSON or a query string, and optionally validates them against a provided schema.
+	 */
+
+	/**
+	 * Extracts and parses the options of the current loader.
+	 * Parses string options as JSON or a query string, and optionally validates them against a provided schema.
+	 */
 	getOptions(schema: Parameters<typeof validateFunction>[0]): OptionsType;
-	emitWarning(warning: Error): void;
-	emitError(error: Error): void;
+
+	/**
+	 * Emits a warning for this module.
+	 * The warning will be displayed to the user during compilation.
+	 */
+	emitWarning(warning: string | Error): void;
+
+	/**
+	 * Emits an error for this module.
+	 * The error will be displayed to the user and typically causes the compilation to fail.
+	 */
+	emitError(error: string | Error): void;
+
+	/**
+	 * Gets a logger instance scoped to this loader and module.
+	 * Useful for emitting debug or compilation information in a structured way.
+	 */
 	getLogger(name?: string): WebpackLogger;
+
+	/**
+	 * Resolves a module request (e.g., a relative path or module name) to an absolute file path.
+	 * It uses Webpack's internal resolver, taking into account configured aliases and extensions.
+	 */
 	resolve(
 		context: string,
 		request: string,
@@ -16670,6 +17450,11 @@ declare interface NormalModuleLoaderContext<OptionsType> {
 			req?: ResolveRequest
 		) => void
 	): void;
+
+	/**
+	 * Creates a resolve function with specific options.
+	 * The returned function can be used as a Promise-based resolver or a callback-based resolver.
+	 */
 	getResolve(options?: ResolveOptionsWithDependencyType): {
 		(
 			context: string,
@@ -16682,6 +17467,11 @@ declare interface NormalModuleLoaderContext<OptionsType> {
 		): void;
 		(context: string, request: string): Promise<string>;
 	};
+
+	/**
+	 * Emits a new file (asset) to the compilation output directory.
+	 * This allows loaders to generate additional files alongside the main module output.
+	 */
 	emitFile(
 		name: string,
 		content: string | Buffer,
@@ -16779,8 +17569,20 @@ type NormalizedStatsOptions = KnownNormalizedStatsOptions &
 declare class NullDependency extends Dependency {
 	constructor();
 	static Template: typeof NullDependencyTemplate;
+
+	/**
+	 * Compares two dependencies by source location for sorting a module's
+	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
+	 * its result, so comparing through it would retain a location object on every
+	 * sorted dependency). These dependencies always carry a real source position,
+	 * so only start (line, column) and the within-statement index are compared; a
+	 * dependency without an index sorts after one that has an index at the same
+	 * position.
+	 */
+	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];
 
 	/**
 	 * Returns true if the dependency is a low priority dependency.
@@ -16792,6 +17594,10 @@ declare class NullDependency extends Dependency {
 	 */
 	static canConcatenate(dependency: Dependency): boolean;
 	static TRANSITIVE: symbol;
+	static LAZY_UNTIL_LOCAL: "local";
+	static LAZY_UNTIL_ID: "id";
+	static LAZY_UNTIL_FALLBACK: "*";
+	static LAZY_UNTIL_REQUEST: "@";
 }
 declare class NullDependencyTemplate extends DependencyTemplate {
 	constructor();
@@ -16803,8 +17609,36 @@ declare interface ObjectConfiguration {
 /**
  * Updates set size using the provided set.
  */
-declare interface ObjectDeserializerContext {
+declare interface ObjectDeserializerContextObjectMiddlewareObject_1 {
+	read: () => string;
+	rest: ObjectDeserializerContextObjectMiddlewareObject_3<[number, boolean]>;
+	setCircularReference: (value: ReferenceableItem) => void;
+}
+declare namespace ObjectDeserializerContextObjectMiddlewareObject_2 {
+	export let read: () => any;
+	export let rest: ObjectDeserializerContextObjectMiddlewareObject_3<
+		ReadonlyArray<any>
+	>;
+	export let setCircularReference: (value: ReferenceableItem) => void;
+}
+
+/**
+ * Updates set size using the provided set.
+ */
+declare interface ObjectDeserializerContextObjectMiddlewareObject_3<
+	T extends ReadonlyArray<any> = ReadonlyArray<any>
+> {
+	read: () => Head<T>;
+	rest: ObjectDeserializerContextObjectMiddlewareObject_3<Tail<T>>;
+	setCircularReference: (value: ReferenceableItem) => void;
+}
+
+/**
+ * Updates set size using the provided set.
+ */
+declare interface ObjectDeserializerContextObjectMiddlewareObject_4 {
 	read: () => any;
+	rest: ObjectDeserializerContextObjectMiddlewareObject_3<ReadonlyArray<any>>;
 	setCircularReference: (value: ReferenceableItem) => void;
 }
 
@@ -16827,39 +17661,116 @@ declare interface ObjectEncodingOptionsFs {
 		| "binary"
 		| "hex";
 }
-declare interface ObjectEncodingOptionsTypes {
-	/**
-	 * encoding
-	 */
-	encoding?:
-		| null
-		| "ascii"
-		| "utf8"
-		| "utf-8"
-		| "utf16le"
-		| "utf-16le"
-		| "ucs2"
-		| "ucs-2"
-		| "base64"
-		| "base64url"
-		| "latin1"
-		| "binary"
-		| "hex";
+declare interface ObjectEncodingOptionsTypes {
+	/**
+	 * encoding
+	 */
+	encoding?:
+		| null
+		| "ascii"
+		| "utf8"
+		| "utf-8"
+		| "utf16le"
+		| "utf-16le"
+		| "ucs2"
+		| "ucs-2"
+		| "base64"
+		| "base64url"
+		| "latin1"
+		| "binary"
+		| "hex";
+}
+
+/**
+ * Updates set size using the provided set.
+ */
+declare interface ObjectSerializer {
+	serialize: (
+		value: any,
+		context: ObjectSerializerContextObjectMiddlewareObject_4<any>
+	) => void;
+	deserialize: (
+		context: ObjectDeserializerContextObjectMiddlewareObject_3<any>
+	) => any;
+}
+
+/**
+ * Updates set size using the provided set.
+ */
+declare interface ObjectSerializerContextObjectMiddlewareObject_1 {
+	write: (
+		value: RestoreProvidedDataExports[]
+	) => ObjectSerializerContextObjectMiddlewareObject_4<
+		[undefined | null | boolean, undefined | boolean, boolean]
+	>;
+	setCircularReference: (value: ReferenceableItem) => void;
+	snapshot: () => ObjectSerializerSnapshot;
+	rollback: (snapshot: ObjectSerializerSnapshot) => void;
+	writeLazy?: (item?: any) => void;
+	writeSeparate?: (
+		item: any,
+		obj?: LazyOptions
+	) => LazyFunction<any, any, any, LazyOptions>;
+}
+
+/**
+ * Updates set size using the provided set.
+ */
+declare interface ObjectSerializerContextObjectMiddlewareObject_2 {
+	write: (
+		value: string
+	) => ObjectSerializerContextObjectMiddlewareObject_4<[number, boolean]>;
+	setCircularReference: (value: ReferenceableItem) => void;
+	snapshot: () => ObjectSerializerSnapshot;
+	rollback: (snapshot: ObjectSerializerSnapshot) => void;
+	writeLazy?: (item?: any) => void;
+	writeSeparate?: (
+		item: any,
+		obj?: LazyOptions
+	) => LazyFunction<any, any, any, LazyOptions>;
+}
+declare namespace ObjectSerializerContextObjectMiddlewareObject_3 {
+	export let write: (
+		value?: any
+	) => ObjectSerializerContextObjectMiddlewareObject_4<ReadonlyArray<any>>;
+	export let setCircularReference: (value: ReferenceableItem) => void;
+	export let snapshot: () => ObjectSerializerSnapshot;
+	export let rollback: (snapshot: ObjectSerializerSnapshot) => void;
+	export let writeLazy: undefined | ((item?: any) => void);
+	export let writeSeparate:
+		| undefined
+		| ((
+				item: any,
+				obj?: LazyOptions
+		  ) => LazyFunction<any, any, any, LazyOptions>);
 }
 
 /**
  * Updates set size using the provided set.
  */
-declare interface ObjectSerializer {
-	serialize: (value: any, context: ObjectSerializerContext) => void;
-	deserialize: (context: ObjectDeserializerContext) => any;
+declare interface ObjectSerializerContextObjectMiddlewareObject_4<
+	T extends ReadonlyArray<any> = ReadonlyArray<any>
+> {
+	write: (
+		value: Head<T>
+	) => ObjectSerializerContextObjectMiddlewareObject_4<Tail<T>>;
+	setCircularReference: (value: ReferenceableItem) => void;
+	snapshot: () => ObjectSerializerSnapshot;
+	rollback: (snapshot: ObjectSerializerSnapshot) => void;
+	writeLazy?: (item?: any) => void;
+	writeSeparate?: (
+		item: any,
+		obj?: LazyOptions
+	) => LazyFunction<any, any, any, LazyOptions>;
 }
 
 /**
  * Updates set size using the provided set.
  */
-declare interface ObjectSerializerContext {
-	write: (value?: any) => void;
+declare interface ObjectSerializerContextObjectMiddlewareObject_5 {
+	write: (
+		value?: any
+	) => ObjectSerializerContextObjectMiddlewareObject_4<ReadonlyArray<any>>;
 	setCircularReference: (value: ReferenceableItem) => void;
 	snapshot: () => ObjectSerializerSnapshot;
 	rollback: (snapshot: ObjectSerializerSnapshot) => void;
@@ -16978,6 +17889,11 @@ declare interface Optimization {
 	 */
 	flagIncludedChunks?: boolean;
 
+	/**
+	 * Inline ESM exports that bind to small primitive constants (≤6-byte null/undefined/boolean/number/string). Inlining makes the import dependency inactive so DCE can drop the export and possibly the module.
+	 */
+	inlineExports?: boolean;
+
 	/**
 	 * Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.
 	 */
@@ -17128,6 +18044,11 @@ declare interface OptimizationNormalized {
 	 */
 	flagIncludedChunks?: boolean;
 
+	/**
+	 * Inline ESM exports that bind to small primitive constants (≤6-byte null/undefined/boolean/number/string). Inlining makes the import dependency inactive so DCE can drop the export and possibly the module.
+	 */
+	inlineExports?: boolean;
+
 	/**
 	 * Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.
 	 */
@@ -17269,6 +18190,7 @@ type OptimizationNormalizedWithDefaults = OptimizationNormalized & {
 	usedExports: NonNullable<undefined | boolean | "global">;
 	mangleExports: NonNullable<undefined | boolean | "deterministic" | "size">;
 	innerGraph: NonNullable<undefined | boolean>;
+	inlineExports: NonNullable<undefined | boolean>;
 	concatenateModules: NonNullable<undefined | boolean>;
 	avoidEntryIife: NonNullable<undefined | boolean>;
 	emitOnErrors: NonNullable<undefined | boolean>;
@@ -17801,6 +18723,11 @@ declare interface Output {
 	 */
 	hotUpdateMainFilename?: string;
 
+	/**
+	 * Generate an HTML file for each non-HTML entrypoint with its JS and CSS output chunks injected. Can be overridden per entry via the entry descriptor `html` option.
+	 */
+	html?: boolean | OutputHtmlOptions;
+
 	/**
 	 * Specifies the filename template of non-initial output html files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
 	 */
@@ -17892,6 +18819,11 @@ declare interface Output {
 	 */
 	strictModuleExceptionHandling?: boolean;
 
+	/**
+	 * Emit a runtime check that throws a 'MODULE_NOT_FOUND' error when a required module id is missing from the bundle.
+	 */
+	strictModuleResolution?: boolean;
+
 	/**
 	 * Use a Trusted Types policy to create urls for chunks. 'output.uniqueName' is used a default policy name. Passing a string sets a custom policy name.
 	 */
@@ -17917,6 +18849,11 @@ declare interface Output {
 	 */
 	webassemblyModuleFilename?: string;
 
+	/**
+	 * Specifies the filename template of non-initial output worker's files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
+	 */
+	workerChunkFilename?: string | TemplatePathFn<PathDataChunk>;
+
 	/**
 	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
 	 */
@@ -17973,6 +18910,16 @@ declare interface OutputFileSystem {
 	dirname?: (dirname: string) => string;
 }
 
+/**
+ * Options for the generated HTML files.
+ */
+declare interface OutputHtmlOptions {
+	/**
+	 * How injected `<script>` tags load. `auto` (default) emits a module script for ES module output and `defer` otherwise; `defer` forces a deferred script; `blocking` emits a plain blocking script.
+	 */
+	scriptLoading?: "auto" | "defer" | "blocking";
+}
+
 /**
  * Normalized options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.
  */
@@ -18126,6 +19073,11 @@ declare interface OutputNormalized {
 	 */
 	hotUpdateMainFilename?: string;
 
+	/**
+	 * Generate an HTML file for each non-HTML entrypoint with its JS and CSS output chunks injected. Can be overridden per entry via the entry descriptor `html` option.
+	 */
+	html?: boolean | OutputHtmlOptions;
+
 	/**
 	 * Specifies the filename template of non-initial output html files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
 	 */
@@ -18207,6 +19159,11 @@ declare interface OutputNormalized {
 	 */
 	strictModuleExceptionHandling?: boolean;
 
+	/**
+	 * Emit a runtime check that throws a 'MODULE_NOT_FOUND' error when a required module id is missing from the bundle.
+	 */
+	strictModuleResolution?: boolean;
+
 	/**
 	 * Use a Trusted Types policy to create urls for chunks.
 	 */
@@ -18227,6 +19184,11 @@ declare interface OutputNormalized {
 	 */
 	webassemblyModuleFilename?: string;
 
+	/**
+	 * Specifies the filename template of non-initial output worker's files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
+	 */
+	workerChunkFilename?: string | TemplatePathFn<PathDataChunk>;
+
 	/**
 	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
 	 */
@@ -18263,6 +19225,9 @@ type OutputNormalizedWithDefaults = OutputNormalized & {
 	devtoolNamespace: string;
 	publicPath: NonNullable<undefined | string | TemplatePathFn<PathData>>;
 	workerPublicPath: string;
+	workerChunkFilename: NonNullable<
+		undefined | string | TemplatePathFn<PathDataChunk>
+	>;
 	workerWasmLoading: NonNullable<undefined | string | false>;
 	workerChunkLoading: NonNullable<undefined | string | false>;
 	chunkFormat: NonNullable<undefined | string | false>;
@@ -18283,6 +19248,7 @@ type OutputNormalizedWithDefaults = OutputNormalized & {
 	compareBeforeEmit: NonNullable<undefined | boolean>;
 	strictModuleErrorHandling: NonNullable<undefined | boolean>;
 	strictModuleExceptionHandling: NonNullable<undefined | boolean>;
+	strictModuleResolution: NonNullable<undefined | boolean>;
 	importFunctionName: string;
 	importMetaName: string;
 	environment: RecursiveNonNullable<Environment>;
@@ -18411,6 +19377,11 @@ declare interface ParserOptionsByModuleTypeKnown {
 	 */
 	"css/module"?: CssAutoOrModuleParserOptions;
 
+	/**
+	 * Parser options for html modules.
+	 */
+	html?: HtmlParserOptions;
+
 	/**
 	 * Parser options for javascript modules.
 	 */
@@ -18470,7 +19441,22 @@ declare interface PathCacheFunctions {
 declare interface PathData {
 	chunkGraph?: ChunkGraph;
 	hash?: string;
+
+	/**
+	 * untruncated compilation hash, for re-encoding `[fullhash:<digest>]`
+	 */
+	fullHash?: string;
+
+	/**
+	 * digest `fullHash` is encoded in (defaults to `hashDigest`)
+	 */
+	fullHashDigest?: string;
 	hashWithLength?: (length: number) => string;
+
+	/**
+	 * builds `[fullhash:<digest>]`/`[hash:<digest>]` in the runtime chunk-filename context, where it throws because a runtime `getFullHash()` expression cannot be re-encoded
+	 */
+	hashWithDigest?: (digest: string, length?: number) => string;
 	chunk?: Chunk | ChunkPathData;
 	module?: Module | ModulePathData;
 	runtime?: RuntimeSpec;
@@ -18479,10 +19465,31 @@ declare interface PathData {
 	query?: string;
 	contentHashType?: string;
 	contentHash?: string;
+
+	/**
+	 * untruncated module/asset content hash, for re-encoding `[contenthash:<digest>]` from full entropy
+	 */
+	contentHashFull?: string;
 	contentHashWithLength?: (length: number) => string;
+
+	/**
+	 * digest the stored hashes are encoded in (for `[hash:<digest>]`)
+	 */
+	hashDigest?: string;
+
+	/**
+	 * whether `optimization.realContentHash` recomputes content hashes (records an inline `[contenthash:<digest>]` so it re-encodes in that digest)
+	 */
+	realContentHash?: boolean;
+
+	/**
+	 * treat `[hash]` as `[fullhash]` rather than the module hash (CSS local idents)
+	 */
+	hashAsFullHash?: boolean;
 	noChunkHash?: boolean;
 	url?: string;
 	local?: string;
+	uniqueName?: string;
 	prepareId?: (id: string | number) => string | number;
 }
 type PathDataChunk = PathData & { chunk: Chunk | ChunkPathData };
@@ -18493,7 +19500,7 @@ type PathDataModule = PathData & {
 type PathLikeFs = string | Buffer | URL;
 type PathLikeTypes = string | URL_url | Buffer;
 type PathOrFileDescriptorFs = string | number | Buffer | URL;
-type PathOrFileDescriptorTypes = string | number | Buffer | URL_url;
+type PathOrFileDescriptorTypes = string | number | URL_url | Buffer;
 type Pattern =
 	| Identifier
 	| MemberExpression
@@ -18541,6 +19548,11 @@ declare interface PitchLoaderDefinitionFunction<
 		data: object
 	): string | void | Buffer | Promise<string | Buffer>;
 }
+
+/**
+ * Should be used only for "target === false" or
+ * when you want to overwrite platform target properties
+ */
 declare class PlatformPlugin {
 	/**
 	 * Creates an instance of PlatformPlugin.
@@ -18578,6 +19590,16 @@ declare interface PlatformTargetProperties {
 	 */
 	node?: null | boolean;
 
+	/**
+	 * deno platform, node built-in modules (via the `node:` specifier) and web APIs are available
+	 */
+	deno?: null | boolean;
+
+	/**
+	 * bun platform, bun and node built-in modules are available
+	 */
+	bun?: null | boolean;
+
 	/**
 	 * nwjs platform, require of legacy nw.gui is available
 	 */
@@ -18587,6 +19609,11 @@ declare interface PlatformTargetProperties {
 	 * electron platform, require of some electron built-in modules is available
 	 */
 	electron?: null | boolean;
+
+	/**
+	 * universal ESM target spanning both web and node (target `"universal"` or `["web", "node"]`)
+	 */
+	universal?: null | boolean;
 }
 type Plugin =
 	| undefined
@@ -18606,10 +19633,6 @@ declare interface PnpApi {
 		options: { considerBuiltins: boolean }
 	) => null | string;
 }
-declare interface Position {
-	line: number;
-	column: number;
-}
 declare class PrefetchPlugin {
 	/**
 	 * Creates an instance of PrefetchPlugin.
@@ -18669,6 +19692,7 @@ type ProblemType =
 	| "unknown-argument"
 	| "unexpected-non-array-in-path"
 	| "unexpected-non-object-in-path"
+	| "prototype-pollution-in-path"
 	| "multiple-values-unexpected"
 	| "invalid-value";
 declare interface ProcessAssetsAdditionalOptions {
@@ -18757,7 +19781,7 @@ declare class ProgressPlugin {
 	static createDefaultHandler: (
 		profile: undefined | null | boolean,
 		logger: WebpackLogger,
-		progressBar:
+		progressBar?:
 			| false
 			| Required<{
 					/**
@@ -18908,6 +19932,9 @@ declare interface ProvidesConfig {
 declare interface ProvidesObject {
 	[index: string]: string | ProvidesConfig;
 }
+type PureCondition =
+	| boolean
+	| ((compilation: Compilation, module: Module) => boolean);
 declare interface RawChunkGroupOptions {
 	preloadOrder?: number;
 	prefetchOrder?: number;
@@ -19762,6 +20789,11 @@ declare interface ReferencedExport {
 	 * when false, referenced export can not be mangled, defaults to true
 	 */
 	canMangle?: boolean;
+
+	/**
+	 * when false, the referenced export can not be substituted with an inlined literal at this site, defaults to true
+	 */
+	canInline?: boolean;
 }
 type Remotes = (string | RemotesObject)[] | RemotesObject;
 
@@ -19967,6 +20999,11 @@ declare class Replacement {
 declare interface RequestRecord {
 	[index: string]: string | string[];
 }
+
+/**
+ * Shortens absolute or verbose request strings so diagnostics and stats output
+ * can be rendered relative to a chosen base directory.
+ */
 declare abstract class RequestShortener {
 	contextify: (value: string) => string;
 
@@ -20426,12 +21463,12 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	/**
 	 * A list of module alias configurations or an object which maps key to value
 	 */
-	alias?: AliasOption[] | AliasOptions;
+	alias?: UserAliasOptions | UserAliasOptionEntry[];
 
 	/**
 	 * A list of module alias configurations or an object which maps key to value, applied only after modules option
 	 */
-	fallback?: AliasOption[] | AliasOptions;
+	fallback?: UserAliasOptions | UserAliasOptionEntry[];
 
 	/**
 	 * An object which maps extension to extension aliases
@@ -20509,9 +21546,9 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	resolver?: Resolver;
 
 	/**
-	 * A list of directories to resolve modules from, can be absolute path or folder name
+	 * A list of directories to resolve modules from, can be absolute path, folder name, or a `file:` `URL` instance
 	 */
-	modules?: string | string[];
+	modules?: string | URL_url | (string | URL_url)[];
 
 	/**
 	 * A list of main fields in description files
@@ -20538,9 +21575,9 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	pnpApi?: null | PnpApi;
 
 	/**
-	 * A list of root paths
+	 * A list of root paths, each an absolute path or a `file:` `URL` instance
 	 */
-	roots?: string[];
+	roots?: (string | URL_url)[];
 
 	/**
 	 * The request is already fully specified and no extensions or directories are resolved for it
@@ -20553,9 +21590,9 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	resolveToContext?: boolean;
 
 	/**
-	 * A list of resolve restrictions
+	 * A list of resolve restrictions, each an absolute path, a `file:` `URL` instance, or a RegExp
 	 */
-	restrictions?: (string | RegExp)[];
+	restrictions?: (string | RegExp | URL_url)[];
 
 	/**
 	 * Use only the sync constraints of the file system calls
@@ -20573,9 +21610,9 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	preferAbsolute?: boolean;
 
 	/**
-	 * TypeScript config file path or config object with configFile and references
+	 * TypeScript config file path (or `file:` `URL` instance) or config object with configFile and references
 	 */
-	tsconfig?: string | boolean | TsconfigOptions;
+	tsconfig?: string | boolean | URL_url | UserTsconfigOptions;
 }
 type ResolveOptionsWithDependencyType = ResolveOptions & {
 	dependencyType?: string;
@@ -20634,30 +21671,30 @@ declare abstract class Resolver {
 		null | ResolveRequest
 	>;
 	resolveSync(
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		resolveContext?: ResolveContext
 	): string | false;
 	resolveSync(
 		context: ContextTypes,
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		resolveContext?: ResolveContext
 	): string | false;
 	resolvePromise(
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		resolveContext?: ResolveContext
 	): Promise<string | false>;
 	resolvePromise(
 		context: ContextTypes,
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		resolveContext?: ResolveContext
 	): Promise<string | false>;
 	resolve(
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		callback: (
 			err: null | ErrorWithDetail,
 			res?: string | false,
@@ -20665,8 +21702,8 @@ declare abstract class Resolver {
 		) => void
 	): void;
 	resolve(
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		resolveContext: ResolveContext,
 		callback: (
 			err: null | ErrorWithDetail,
@@ -20676,8 +21713,8 @@ declare abstract class Resolver {
 	): void;
 	resolve(
 		context: ContextTypes,
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		callback: (
 			err: null | ErrorWithDetail,
 			res?: string | false,
@@ -20686,8 +21723,8 @@ declare abstract class Resolver {
 	): void;
 	resolve(
 		context: ContextTypes,
-		path: string,
-		request: string,
+		parent: string | URL_url,
+		specifier: string | URL_url,
 		resolveContext: ResolveContext,
 		callback: (
 			err: null | ErrorWithDetail,
@@ -20786,13 +21823,15 @@ declare abstract class RestoreProvidedData {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContext): void;
+	serialize(context: ObjectSerializerContextObjectMiddlewareObject_1): void;
 }
 declare interface RestoreProvidedDataExports {
 	name: string;
 	provided?: null | boolean;
 	canMangleProvide?: boolean;
+	canInlineProvide?: InlinedValue;
 	terminalBinding: boolean;
+	pureProvide?: boolean;
 	exportsInfo?: RestoreProvidedData;
 }
 type Rule = string | RegExp | ((str: string) => boolean);
@@ -21324,6 +22363,10 @@ declare interface RuntimeRequirementsContext {
 	codeGenerationResults: CodeGenerationResults;
 }
 type RuntimeSpec = undefined | string | SortableSet<string>;
+
+/**
+ * Represents RuntimeSpecMap.
+ */
 declare class RuntimeSpecMap<T, R = T> {
 	/**
 	 * Creates an instance of RuntimeSpecMap.
@@ -21398,11 +22441,35 @@ declare abstract class RuntimeTemplate {
 	isIIFE(): boolean;
 	isModule(): boolean;
 	isNeutralPlatform(): boolean;
+
+	/**
+	 * Whether the bundle targets node and web at once (universal `["node", "web"]` + `output.module`), like `isUniversalTarget` in `WebpackOptionsApply`.
+	 */
+	isUniversalTarget(): boolean;
+
+	/**
+	 * Runtime expression that is truthy in browser-like environments (a DOM
+	 * `document` or a worker `self`) and falsy in Node.js. Single source of
+	 * truth for branching a universal ("node-or-web") target at runtime.
+	 */
+	isWebLikePlatformExpression(): string;
+
+	/**
+	 * Expression for the global registry that collects CSS server-side when there
+	 * is no DOM (SSR). An SSR host reads it from `globalThis`; it is keyed by the
+	 * style/chunk identifier and namespaced by `output.uniqueName`.
+	 */
+	cssServerStyleRegistry(): string;
 	supportsConst(): boolean;
+	supportsLet(): boolean;
 	supportsMethodShorthand(): boolean;
+	supportsLogicalAssignment(): boolean;
 	supportsArrowFunction(): boolean;
 	supportsAsyncFunction(): boolean;
 	supportsOptionalChaining(): boolean;
+	supportsSpread(): boolean;
+	supportsObjectHasOwn(): boolean;
+	supportsSymbol(): boolean;
 	supportsForOf(): boolean;
 	supportsDestructuring(): boolean;
 	supportsBigIntLiteral(): boolean;
@@ -21417,9 +22484,14 @@ declare abstract class RuntimeTemplate {
 	renderNodePrefixForCoreModule(mod: string): string;
 
 	/**
-	 * Renders return const when it is supported, otherwise var.
+	 * Renders return const when it is supported, otherwise let when supported, otherwise var.
+	 */
+	renderConst(): "var" | "const" | "let";
+
+	/**
+	 * Renders return let when it is supported, otherwise var.
 	 */
-	renderConst(): "var" | "const";
+	renderLet(): "var" | "let";
 
 	/**
 	 * Returning function.
@@ -21446,6 +22518,40 @@ declare abstract class RuntimeTemplate {
 	 */
 	emptyFunction(): string;
 
+	/**
+	 * Guards an access/call on `object` with optional chaining when supported,
+	 * otherwise an equivalent `&&` short-circuit. `object` is evaluated twice in
+	 * the fallback, so it must be side-effect free.
+	 */
+	optionalChaining(object: string, access: string): string;
+
+	/**
+	 * Reads a node builtin via `process.getBuiltinModule()`, guarded to stay falsy off node so universal `["node", "web"]` bundles don't crash (also falsy on node <22.3).
+	 */
+	getBuiltinModule(request: string, access?: string): string;
+
+	/**
+	 * Renders an object-literal method, using method shorthand when supported
+	 * and falling back to a `prop: function/arrow` property otherwise.
+	 */
+	method(prop: string, args: string, body: string | string[]): string;
+
+	/**
+	 * Returns an own-property check, using `Object.hasOwn` when supported and
+	 * falling back to `Object.prototype.hasOwnProperty.call` otherwise.
+	 */
+	objectHasOwn(object: string, property: string): string;
+
+	/**
+	 * Returns a self-defaulting assignment, using the `||=` logical assignment
+	 * operator when supported and falling back to `target = target || value`
+	 * otherwise. `target` is evaluated twice in the fallback, so it must be
+	 * side-effect free. The expression evaluates to the resulting value.
+	 * Models `||` only, so `target` must never hold a legitimate falsy value
+	 * (`0`, `""`, `false`) — it would be overwritten; use it for object/array defaults.
+	 */
+	assignOr(target: string, value: string): string;
+
 	/**
 	 * Returns destructure array code.
 	 */
@@ -21846,6 +22952,10 @@ declare abstract class RuntimeTemplate {
 		 * module dependency
 		 */
 		dependency: ModuleDependency;
+		/**
+		 * true, when a whole-namespace value may use a decoupled namespace object that keeps the original export names
+		 */
+		mangleableNamespace?: boolean;
 	}): string;
 
 	/**
@@ -22000,6 +23110,10 @@ declare interface ScopeInfo {
 declare interface Selector<A, B> {
 	(input: A): undefined | null | B;
 }
+
+/**
+ * Represents Serializer.
+ */
 declare abstract class Serializer<DeserializedValue, SerializedValue, Context> {
 	serializeMiddlewares: SerializerMiddleware<any, any, any>[];
 	deserializeMiddlewares: SerializerMiddleware<any, any, any>[];
@@ -22021,6 +23135,10 @@ declare abstract class Serializer<DeserializedValue, SerializedValue, Context> {
 		context: Context & ExtendedContext
 	): Promise<DeserializedValue>;
 }
+
+/**
+ * Represents SerializerMiddleware.
+ */
 declare abstract class SerializerMiddleware<
 	DeserializedType,
 	SerializedType,
@@ -22268,12 +23386,12 @@ declare abstract class Snapshot {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContext): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContext): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
 
 	/**
 	 * Gets file iterable.
@@ -22439,6 +23557,10 @@ declare interface SnapshotOptionsWebpackOptions {
 declare interface SortFunction<T> {
 	(a: T, b: T): number;
 }
+
+/**
+ * A subset of Set that offers sorting functionality
+ */
 declare abstract class SortableSet<T> extends Set<T> {
 	/**
 	 * Sort with a comparer function
@@ -22470,6 +23592,19 @@ declare class Source {
 	map(options?: MapOptions): null | RawSourceMap;
 	sourceAndMap(options?: MapOptions): SourceAndMap;
 	updateHash(hash: HashLike): void;
+
+	/**
+	 * Release cached data held by this source. clearCache is a memory
+	 * hint: it never affects correctness or output, only how expensive
+	 * the next read is. Subclasses override; the base is a no-op so
+	 * every Source supports the call. Composite sources always recurse
+	 * into wrapped sources. When the same child is reachable via several
+	 * parents (e.g. modules shared across webpack chunks), pass a shared
+	 * `visited` WeakSet so each subtree is walked at most once.
+	 * Not safe to call concurrently with source/map/sourceAndMap/
+	 * streamChunks/updateHash on the same instance.
+	 */
+	clearCache(options?: ClearCacheOptions, visited?: WeakSet<Source>): void;
 }
 declare interface SourceAndMap {
 	/**
@@ -22482,6 +23617,11 @@ declare interface SourceAndMap {
 	 */
 	map: null | RawSourceMap;
 }
+declare interface SourceItem {
+	type: SourceTypeOrResolver;
+	filter?: (attributes: Map<string, string>, value: string) => boolean;
+	namespace?: number;
+}
 declare interface SourceLike {
 	/**
 	 * source
@@ -22517,6 +23657,11 @@ declare interface SourceLike {
 	 * hash updater
 	 */
 	updateHash?: (hash: HashLike) => void;
+
+	/**
+	 * clear cache
+	 */
+	clearCache?: (options?: ClearCacheOptions, visited?: WeakSet<Source>) => void;
 }
 declare class SourceMapDevToolPlugin {
 	/**
@@ -22660,6 +23805,31 @@ declare interface SourcePosition {
 	line: number;
 	column?: number;
 }
+type SourceType =
+	| "script"
+	| "css-url"
+	| "stylesheet"
+	| "script-module"
+	| "modulepreload"
+	| "src"
+	| "srcset"
+	| "stylesheet-style"
+	| "stylesheet-style-attribute"
+	| "srcdoc"
+	| "msapplication-task";
+type SourceTypeOrResolver =
+	| "script"
+	| "css-url"
+	| "stylesheet"
+	| "script-module"
+	| "modulepreload"
+	| "src"
+	| "srcset"
+	| "stylesheet-style"
+	| "stylesheet-style-attribute"
+	| "srcdoc"
+	| "msapplication-task"
+	| ((attrs: Map<string, string>, css: boolean) => SourceType);
 type SourceValue = string | Buffer;
 declare interface SplitChunksOptions {
 	chunksFilter: (chunk: Chunk) => undefined | boolean;
@@ -22707,6 +23877,15 @@ declare interface SplitData {
 	modules: string[];
 	size: number;
 }
+
+/**
+ * Singly-linked stack entry that also exposes a Set-like API
+ * (`has`, `size`, iteration). Each `doResolve` call prepends a new
+ * `StackEntry` that points at the previous tip via `.parent`, so pushing
+ * is O(1) in time and memory. Recursion detection walks the linked list
+ * (O(n)) but the stack is typically shallow, so this is cheaper overall
+ * than cloning a `Set` per call.
+ */
 declare abstract class StackEntry {
 	name?: string;
 	path: string | false;
@@ -22752,7 +23931,27 @@ declare abstract class StackEntry {
 	 * at the formatted form.
 	 */
 	toString(): string;
+
+	/**
+	 * Iterate entries from oldest (root) to newest (tip), matching how a
+	 * `Set` that was populated in insertion order would iterate. Pre-seeded
+	 * legacy `Set<string>` entries come first so error-message output stays
+	 * ordered oldest-to-newest.
+	 * Yields each entry as its formatted `toString()` form. Plugins written
+	 * against the pre-5.21 `Set<string>` shape — e.g.
+	 * `[...resolveContext.stack].find(a => a.includes("module:"))` — keep
+	 * working unchanged because each yielded value is a plain string with
+	 * all of `String.prototype` available natively. Resolves that never
+	 * iterate the stack pay nothing; iteration costs one `toString()`
+	 * allocation per stack frame.
+	 */
+	[Symbol.iterator](): IterableIterator<string>;
 }
+
+/**
+ * Layered map that supports child scopes while memoizing lookups from parent
+ * scopes into the current layer.
+ */
 declare abstract class StackedMap<K, V> {
 	map: Map<K, InternalCell<V>>;
 	stack: Map<K, InternalCell<V>>[];
@@ -22812,6 +24011,32 @@ declare abstract class StackedMap<K, V> {
 	 */
 	createChild(): StackedMap<K, V>;
 }
+
+/**
+ * Updates set size using the provided set.
+ */
+declare interface StarListDeserializerContext {
+	read: () => HarmonyExportImportedSpecifierDependency[];
+	rest: ObjectDeserializerContextObjectMiddlewareObject_3<[]>;
+	setCircularReference: (value: ReferenceableItem) => void;
+}
+
+/**
+ * Updates set size using the provided set.
+ */
+declare interface StarListSerializerContext {
+	write: (
+		value: HarmonyExportImportedSpecifierDependency[]
+	) => ObjectSerializerContextObjectMiddlewareObject_4<[]>;
+	setCircularReference: (value: ReferenceableItem) => void;
+	snapshot: () => ObjectSerializerSnapshot;
+	rollback: (snapshot: ObjectSerializerSnapshot) => void;
+	writeLazy?: (item?: any) => void;
+	writeSeparate?: (
+		item: any,
+		obj?: LazyOptions
+	) => LazyFunction<any, any, any, LazyOptions>;
+}
 declare interface StartupRenderContext {
 	/**
 	 * the chunk
@@ -23768,6 +24993,9 @@ declare interface SyncModuleIdsPluginOptions {
 	 */
 	mode?: "read" | "create" | "merge" | "update";
 }
+type SyncWasmModuleBuildMeta = KnownBuildMeta &
+	Record<string, any> &
+	KnownSyncWasmModuleBuildMeta;
 declare interface SyntheticDependencyLocation {
 	name: string;
 	index?: number;
@@ -23782,10 +25010,12 @@ declare interface TagInfo {
 		| HarmonySettings
 		| ImportSettings
 		| CommonJsImportSettings
-		| CompatibilitySettings
-		| HarmonySpecifierGuards;
+		| CompatibilitySettings;
 	next?: TagInfo;
 }
+type Tail<T extends ReadonlyArray<any>> = T extends readonly [any, ...infer R]
+	? R
+	: T;
 declare interface TargetItemWithConnection {
 	module: Module;
 	connection: ModuleGraphConnection;
@@ -23897,8 +25127,19 @@ declare class TopLevelSymbol {
 	/**
 	 * Creates an instance of TopLevelSymbol.
 	 */
-	constructor(name: string);
+	constructor(
+		name: string,
+		pure?: boolean | ((compilation: Compilation, module: Module) => boolean)
+	);
 	name: string;
+	conditional: boolean;
+	pureFn?: (compilation: Compilation, module: Module) => boolean;
+
+	/**
+	 * Sets the pure condition
+	 */
+	setPure(pure: PureCondition): void;
+	isPure(compilation: Compilation, module: Module): boolean;
 }
 
 /**
@@ -23935,7 +25176,7 @@ declare interface TsconfigPathsData {
 	/**
 	 * tsconfig file data
 	 */
-	alias: CompiledAliasOption[];
+	alias: CompiledAliasOptions;
 
 	/**
 	 * tsconfig file data
@@ -23992,7 +25233,36 @@ declare interface UpdateHashContextGenerator {
 }
 type Usage = string | true | TopLevelSymbol;
 type UsageStateType = 0 | 1 | 2 | 3 | 4;
-type UsedName = string | false | string[];
+type UsedName = string | false | string[] | InlinedUsedName;
+declare interface UserAliasOptionEntry {
+	alias: UserAliasOptionNewRequest;
+	name: string;
+	onlyModule?: boolean;
+}
+type UserAliasOptionNewRequest =
+	| string
+	| false
+	| URL_url
+	| (string | URL_url)[];
+declare interface UserAliasOptions {
+	[index: string]: UserAliasOptionNewRequest;
+}
+declare interface UserTsconfigOptions {
+	/**
+	 * A path, or `file:` `URL` instance, pointing at the tsconfig file
+	 */
+	configFile?: string | URL_url;
+
+	/**
+	 * References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths or `file:` `URL` instances
+	 */
+	references?: "auto" | (string | URL_url)[];
+
+	/**
+	 * Override baseUrl from tsconfig.json with a path or `file:` `URL` instance
+	 */
+	baseUrl?: string | URL_url;
+}
 type Value = string | number | boolean | RegExp;
 type ValueCacheVersion = string | Set<string>;
 declare interface Values {
@@ -24332,6 +25602,11 @@ declare abstract class Watching {
 	 */
 	close(callback: (err: null | Error, result?: void) => void): void;
 }
+
+/**
+ * Stores values by tuple keys while using `WeakMap` for object elements so the
+ * cache can release entries when those objects are collected.
+ */
 declare abstract class WeakTupleMap<K extends any[], V> {
 	/**
 	 * Stores a value at the node identified by the provided tuple key.
@@ -24354,6 +25629,19 @@ declare abstract class WeakTupleMap<K extends any[], V> {
 	 */
 	provide(...args: [K, ...((...args: K) => V)[]]): V;
 
+	/**
+	 * Memoizes `compute(thisArg, ...args)` under the tuple key `[compute,
+	 * ...args]`, computing it on a miss. Equivalent to `provide(compute, ...args,
+	 * () => compute(thisArg, ...args))` but without allocating that closure (or an
+	 * extra rest array) on every call — `ModuleGraph#cached` runs this on hot
+	 * paths where most calls hit the cache and the closure would be pure waste.
+	 */
+	cachedProvide(
+		compute: (thisArg: any, ...args: K) => V,
+		thisArg: any,
+		args: K
+	): V;
+
 	/**
 	 * Removes the value stored for the tuple key without pruning the trie.
 	 */
@@ -24420,12 +25708,12 @@ declare class WebpackError extends Error {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContext): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContext): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
 
 	/**
 	 * Creates a `.stack` property on `targetObject`, which when accessed returns
@@ -25019,6 +26307,7 @@ declare function exports(
 declare function exports(options: MultiConfiguration): MultiCompiler;
 declare namespace exports {
 	export const webpack: _functionWebpack;
+	export const defineConfig: <T extends DefineConfigInput>(config: T) => T;
 	export const validate: (
 		configuration: Configuration | MultiConfiguration
 	) => void;
@@ -25212,6 +26501,7 @@ declare namespace exports {
 		export let toBinary: "__webpack_require__.tb";
 		export let uncaughtErrorHandler: "__webpack_require__.oe";
 		export let wasmInstances: "__webpack_require__.w";
+		export let worker: "__webpack_require__.wc";
 	}
 	export const UsageState: Readonly<{
 		Unused: 0;
@@ -25262,21 +26552,8 @@ declare namespace exports {
 	}
 	export namespace optimize {
 		export namespace InnerGraph {
-			export let addUsage: (
-				state: ParserState,
-				symbol: null | TopLevelSymbol,
-				usage: Usage
-			) => void;
-			export let addVariableUsage: (
-				parser: JavascriptParser,
-				name: string,
-				usage: Usage
-			) => void;
-			export let bailout: (parserState: ParserState) => void;
-			export let enable: (parserState: ParserState) => void;
 			export let getDependencyUsedByExportsCondition: (
 				dependency: Dependency,
-				usedByExports: undefined | boolean | Set<string>,
 				moduleGraph: ModuleGraph
 			) =>
 				| null
@@ -25285,29 +26562,9 @@ declare namespace exports {
 						moduleGraphConnection: ModuleGraphConnection,
 						runtime: RuntimeSpec
 				  ) => ConnectionState);
-			export let getTopLevelSymbol: (
-				state: ParserState
-			) => void | TopLevelSymbol;
-			export let inferDependencyUsage: (state: ParserState) => void;
-			export let isDependencyUsedByExports: (
-				dependency: Dependency,
-				usedByExports: undefined | boolean | Set<string>,
-				moduleGraph: ModuleGraph,
-				runtime: RuntimeSpec
-			) => boolean;
-			export let isEnabled: (parserState: ParserState) => boolean;
-			export let onUsage: (
-				state: ParserState,
-				onUsageCallback: (value?: boolean | Set<string>) => void
-			) => void;
-			export let setTopLevelSymbol: (
-				state: ParserState,
-				symbol?: TopLevelSymbol
-			) => void;
-			export let tagTopLevelSymbol: (
-				parser: JavascriptParser,
-				name: string
-			) => undefined | TopLevelSymbol;
+			export let getInnerGraphUtils: (
+				compilation: Compilation
+			) => InnerGraphUtils;
 			export { TopLevelSymbol, topLevelSymbolTag };
 		}
 		export {
@@ -25651,6 +26908,14 @@ declare namespace exports {
 	export type ExternalItemFunctionPromise = (
 		data: ExternalItemFunctionData
 	) => Promise<ExternalItemValue>;
+	export type ConfigurationFactory = (
+		env: Record<string, any>,
+		argv: Record<string, any>
+	) => MaybePromise<Configuration | MultiConfiguration>;
+	export type ObjectSerializerContext =
+		typeof ObjectSerializerContextObjectMiddlewareObject_3;
+	export type ObjectDeserializerContext =
+		typeof ObjectDeserializerContextObjectMiddlewareObject_2;
 	export {
 		AutomaticPrefetchPlugin,
 		AsyncDependenciesBlock,
@@ -25738,8 +27003,22 @@ declare namespace exports {
 		Configuration,
 		WebpackOptionsNormalized,
 		WebpackPluginInstance,
+		AssetModuleBuildInfo,
 		ChunkGroup,
 		AssetEmittedInfo,
+		ContextModuleBuildInfo,
+		CssModuleBuildInfo,
+		CssModuleBuildMeta,
+		ExternalModuleBuildInfo,
+		HtmlModuleBuildInfo,
+		JavascriptModuleBuildInfo,
+		JavascriptModuleBuildMeta,
+		JsonModuleBuildInfo,
+		BuildInfo,
+		BuildMeta,
+		NormalModuleBuildInfo,
+		ConcatenatedModuleBuildInfo,
+		SyncWasmModuleBuildMeta,
 		Asset,
 		AssetInfo,
 		EntryOptions,
@@ -25765,6 +27044,7 @@ declare namespace exports {
 		Problem,
 		Colors,
 		ColorsOptions,
+		DefineConfigInput,
 		StatsAsset,
 		StatsChunk,
 		StatsChunkGroup,
@@ -25779,8 +27059,6 @@ declare namespace exports {
 		StatsModuleTraceDependency,
 		StatsModuleTraceItem,
 		StatsProfile,
-		ObjectSerializerContext,
-		ObjectDeserializerContext,
 		InputFileSystem,
 		OutputFileSystem,
 		LoaderModule,