@rspack/core 1.1.0 → 1.1.2

package/dist/index.js

@@ -696,6 +696,8 @@ __export(src_exports, {
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
+  DllPlugin: () => DllPlugin,
+  DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
@@ -758,6 +760,8 @@ __export(exports_exports, {
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
+  DllPlugin: () => DllPlugin,
+  DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
@@ -809,7 +813,7 @@ __export(exports_exports, {
 var import_package = require("../package.json");
 
 // src/Compilation.ts
-var import_binding7 = require("@rspack/binding");
+var import_binding6 = require("@rspack/binding");
 var liteTapable = __toESM(require("@rspack/lite-tapable"));
 
 // src/Chunk.ts
@@ -1077,24 +1081,15 @@ var Chunk = class _Chunk {
   __internal__innerUkey() {
     return this.#inner.__inner_ukey;
   }
-  __internal_to_path_data_chunk() {
-    return {
-      id: this.id,
-      name: this.name,
-      hash: this.hash,
-      contentHash: this.contentHash
-    };
-  }
 };
 
 // src/ChunkGraph.ts
-var import_binding5 = require("@rspack/binding");
+var import_binding4 = require("@rspack/binding");
 
 // src/Module.ts
-var import_binding4 = require("@rspack/binding");
+var import_binding3 = require("@rspack/binding");
 
 // src/Dependency.ts
-var import_binding3 = require("@rspack/binding");
 var Dependency = class _Dependency {
   static __from_binding(binding3) {
     return new _Dependency(binding3);
@@ -1125,9 +1120,7 @@ var Dependency = class _Dependency {
           return binding3.critical;
         },
         set(val) {
-          if (binding3 instanceof import_binding3.JsDependencyMut) {
-            binding3.critical = val;
-          }
+          binding3.critical = val;
         }
       }
     });
@@ -1392,7 +1385,7 @@ var Module = class _Module {
       modules: {
         enumerable: true,
         get() {
-          if (module2 instanceof import_binding4.JsModule) {
+          if (module2 instanceof import_binding3.JsModule) {
             return module2.modules ? module2.modules.map((m) => _Module.__from_binding(m)) : void 0;
           }
           return void 0;
@@ -1480,14 +1473,14 @@ var ChunkGraph = class {
     this.compilation = compilation;
   }
   getChunkModules(chunk) {
-    return (0, import_binding5.__chunk_graph_inner_get_chunk_modules)(
+    return (0, import_binding4.__chunk_graph_inner_get_chunk_modules)(
       chunk.__internal__innerUkey(),
       this.compilation.__internal_getInner()
     ).map((m) => Module.__from_binding(m, this.compilation));
   }
   getChunkModulesIterable(chunk) {
     return new Set(
-      (0, import_binding5.__chunk_graph_inner_get_chunk_modules)(
+      (0, import_binding4.__chunk_graph_inner_get_chunk_modules)(
         chunk.__internal__innerUkey(),
         this.compilation.__internal_getInner()
       ).map((m) => Module.__from_binding(m, this.compilation))
@@ -1495,7 +1488,7 @@ var ChunkGraph = class {
   }
   getChunkEntryModulesIterable(chunk) {
     return new Set(
-      (0, import_binding5.__chunk_graph_inner_get_chunk_entry_modules)(
+      (0, import_binding4.__chunk_graph_inner_get_chunk_entry_modules)(
         chunk.__internal__innerUkey(),
         this.compilation.__internal_getInner()
       ).map((m) => Module.__from_binding(m, this.compilation))
@@ -1503,7 +1496,7 @@ var ChunkGraph = class {
   }
   getChunkEntryDependentChunksIterable(chunk) {
     return new Set(
-      (0, import_binding5.__chunk_graph_inner_get_chunk_entry_dependent_chunks_iterable)(
+      (0, import_binding4.__chunk_graph_inner_get_chunk_entry_dependent_chunks_iterable)(
         chunk.__internal__innerUkey(),
         this.compilation.__internal_getInner()
       ).map(
@@ -1513,7 +1506,7 @@ var ChunkGraph = class {
   }
   getChunkModulesIterableBySourceType(chunk, sourceType) {
     return new Set(
-      (0, import_binding5.__chunk_graph_inner_get_chunk_modules_iterable_by_source_type)(
+      (0, import_binding4.__chunk_graph_inner_get_chunk_modules_iterable_by_source_type)(
         chunk.__internal__innerUkey(),
         sourceType,
         this.compilation.__internal_getInner()
@@ -1523,7 +1516,7 @@ var ChunkGraph = class {
 };
 
 // src/Entrypoint.ts
-var import_binding6 = require("@rspack/binding");
+var import_binding5 = require("@rspack/binding");
 var Entrypoint = class _Entrypoint extends ChunkGroup {
   static __from_binding(chunk, compilation) {
     return new _Entrypoint(chunk, compilation);
@@ -1532,7 +1525,7 @@ var Entrypoint = class _Entrypoint extends ChunkGroup {
     super(inner, compilation);
   }
   getRuntimeChunk() {
-    const c = (0, import_binding6.__entrypoint_inner_get_runtime_chunk)(
+    const c = (0, import_binding5.__entrypoint_inner_get_runtime_chunk)(
       this.__internal__innerUkey(),
       this.__internal__innerCompilation()
     );
@@ -3167,7 +3160,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
           for (let i = 0; i < errs.length; i++) {
             const error = errs[i];
             inner.pushDiagnostic(
-              JsRspackDiagnostic.__to_binding(error, import_binding7.JsRspackSeverity.Error)
+              JsRspackDiagnostic.__to_binding(error, import_binding6.JsRspackSeverity.Error)
             );
           }
           return Reflect.apply(target2, thisArg, errs);
@@ -3193,7 +3186,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
           const errList = errs.map((error) => {
             return JsRspackDiagnostic.__to_binding(
               error,
-              import_binding7.JsRspackSeverity.Error
+              import_binding6.JsRspackSeverity.Error
             );
           });
           inner.spliceDiagnostic(0, 0, errList);
@@ -3206,7 +3199,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
           const errList = errors2.map((error) => {
             return JsRspackDiagnostic.__to_binding(
               error,
-              import_binding7.JsRspackSeverity.Error
+              import_binding6.JsRspackSeverity.Error
             );
           });
           inner.spliceDiagnostic(startIdx, startIdx + delCount, errList);
@@ -3233,7 +3226,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
       0,
       length,
       errors.map((error) => {
-        return JsRspackDiagnostic.__to_binding(error, import_binding7.JsRspackSeverity.Error);
+        return JsRspackDiagnostic.__to_binding(error, import_binding6.JsRspackSeverity.Error);
       })
     );
   }
@@ -3250,7 +3243,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             thisArg,
             processWarningsHook.call(warns).map((warn) => {
               inner.pushDiagnostic(
-                JsRspackDiagnostic.__to_binding(warn, import_binding7.JsRspackSeverity.Warn)
+                JsRspackDiagnostic.__to_binding(warn, import_binding6.JsRspackSeverity.Warn)
               );
               return warn;
             })
@@ -3281,7 +3274,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             warnings2.map((warn) => {
               return JsRspackDiagnostic.__to_binding(
                 warn,
-                import_binding7.JsRspackSeverity.Warn
+                import_binding6.JsRspackSeverity.Warn
               );
             })
           );
@@ -3293,7 +3286,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         handler(target2, thisArg, [startIdx, delCount, ...warns]) {
           warns = processWarningsHook.call(warns);
           const warnList = warns.map((warn) => {
-            return JsRspackDiagnostic.__to_binding(warn, import_binding7.JsRspackSeverity.Warn);
+            return JsRspackDiagnostic.__to_binding(warn, import_binding6.JsRspackSeverity.Warn);
           });
           inner.spliceDiagnostic(startIdx, startIdx + delCount, warnList);
           return Reflect.apply(target2, thisArg, [
@@ -3319,33 +3312,41 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
       0,
       length,
       warnings.map((warning) => {
-        return JsRspackDiagnostic.__to_binding(warning, import_binding7.JsRspackSeverity.Warn);
+        return JsRspackDiagnostic.__to_binding(warning, import_binding6.JsRspackSeverity.Warn);
       })
     );
   }
   getPath(filename2, data = {}) {
-    return __privateGet(this, _inner).getPath(filename2, {
-      ...data,
-      chunk: data.chunk instanceof Chunk ? data.chunk.__internal_to_path_data_chunk() : data.chunk
-    });
+    var _a;
+    const pathData = { ...data };
+    if (data.contentHashType && ((_a = data.chunk) == null ? void 0 : _a.contentHash)) {
+      pathData.contentHash = data.chunk.contentHash[data.contentHashType];
+    }
+    return __privateGet(this, _inner).getPath(filename2, pathData);
   }
   getPathWithInfo(filename2, data = {}) {
-    return __privateGet(this, _inner).getPathWithInfo(filename2, {
-      ...data,
-      chunk: data.chunk instanceof Chunk ? data.chunk.__internal_to_path_data_chunk() : data.chunk
-    });
+    var _a;
+    const pathData = { ...data };
+    if (data.contentHashType && ((_a = data.chunk) == null ? void 0 : _a.contentHash)) {
+      pathData.contentHash = data.chunk.contentHash[data.contentHashType];
+    }
+    return __privateGet(this, _inner).getPathWithInfo(filename2, pathData);
   }
   getAssetPath(filename2, data = {}) {
-    return __privateGet(this, _inner).getAssetPath(filename2, {
-      ...data,
-      chunk: data.chunk instanceof Chunk ? data.chunk.__internal_to_path_data_chunk() : data.chunk
-    });
+    var _a;
+    const pathData = { ...data };
+    if (data.contentHashType && ((_a = data.chunk) == null ? void 0 : _a.contentHash)) {
+      pathData.contentHash = data.chunk.contentHash[data.contentHashType];
+    }
+    return __privateGet(this, _inner).getAssetPath(filename2, pathData);
   }
   getAssetPathWithInfo(filename2, data = {}) {
-    return __privateGet(this, _inner).getAssetPathWithInfo(filename2, {
-      ...data,
-      chunk: data.chunk instanceof Chunk ? data.chunk.__internal_to_path_data_chunk() : data.chunk
-    });
+    var _a;
+    const pathData = { ...data };
+    if (data.contentHashType && ((_a = data.chunk) == null ? void 0 : _a.contentHash)) {
+      pathData.contentHash = data.chunk.contentHash[data.contentHashType];
+    }
+    return __privateGet(this, _inner).getAssetPathWithInfo(filename2, pathData);
   }
   getLogger(name2) {
     if (!name2) {
@@ -5086,40 +5087,40 @@ function create2(name2, resolve2, affectedHooks) {
 }
 
 // src/builtin-plugin/APIPlugin.ts
-var import_binding8 = require("@rspack/binding");
-var APIPlugin = create2(import_binding8.BuiltinPluginName.APIPlugin, () => {
+var import_binding7 = require("@rspack/binding");
+var APIPlugin = create2(import_binding7.BuiltinPluginName.APIPlugin, () => {
 });
 
 // src/builtin-plugin/ArrayPushCallbackChunkFormatPlugin.ts
-var import_binding9 = require("@rspack/binding");
+var import_binding8 = require("@rspack/binding");
 var ArrayPushCallbackChunkFormatPlugin = create2(
-  import_binding9.BuiltinPluginName.ArrayPushCallbackChunkFormatPlugin,
+  import_binding8.BuiltinPluginName.ArrayPushCallbackChunkFormatPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/AssetModulesPlugin.ts
-var import_binding10 = require("@rspack/binding");
+var import_binding9 = require("@rspack/binding");
 var AssetModulesPlugin = create2(
-  import_binding10.BuiltinPluginName.AssetModulesPlugin,
+  import_binding9.BuiltinPluginName.AssetModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/AsyncWebAssemblyModulesPlugin.ts
-var import_binding11 = require("@rspack/binding");
+var import_binding10 = require("@rspack/binding");
 var AsyncWebAssemblyModulesPlugin = create2(
-  import_binding11.BuiltinPluginName.AsyncWebAssemblyModulesPlugin,
+  import_binding10.BuiltinPluginName.AsyncWebAssemblyModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/BannerPlugin.ts
-var import_binding12 = require("@rspack/binding");
+var import_binding11 = require("@rspack/binding");
 var BannerPlugin = create2(
-  import_binding12.BuiltinPluginName.BannerPlugin,
+  import_binding11.BuiltinPluginName.BannerPlugin,
   (args) => {
     if (typeof args === "string" || typeof args === "function") {
       return {
@@ -5140,9 +5141,9 @@ var BannerPlugin = create2(
 );
 
 // src/builtin-plugin/BundlerInfoRspackPlugin.ts
-var import_binding13 = require("@rspack/binding");
+var import_binding12 = require("@rspack/binding");
 var BundlerInfoRspackPlugin = create2(
-  import_binding13.BuiltinPluginName.BundlerInfoRspackPlugin,
+  import_binding12.BuiltinPluginName.BundlerInfoRspackPlugin,
   (options) => {
     return {
       version: options.version || "unknown",
@@ -5153,25 +5154,25 @@ var BundlerInfoRspackPlugin = create2(
 );
 
 // src/builtin-plugin/ChunkPrefetchPreloadPlugin.ts
-var import_binding14 = require("@rspack/binding");
+var import_binding13 = require("@rspack/binding");
 var ChunkPrefetchPreloadPlugin = create2(
-  import_binding14.BuiltinPluginName.ChunkPrefetchPreloadPlugin,
+  import_binding13.BuiltinPluginName.ChunkPrefetchPreloadPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/CommonJsChunkFormatPlugin.ts
-var import_binding15 = require("@rspack/binding");
+var import_binding14 = require("@rspack/binding");
 var CommonJsChunkFormatPlugin = create2(
-  import_binding15.BuiltinPluginName.CommonJsChunkFormatPlugin,
+  import_binding14.BuiltinPluginName.CommonJsChunkFormatPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/CopyRspackPlugin.ts
-var import_binding16 = require("@rspack/binding");
+var import_binding15 = require("@rspack/binding");
 var CopyRspackPlugin = create2(
-  import_binding16.BuiltinPluginName.CopyRspackPlugin,
+  import_binding15.BuiltinPluginName.CopyRspackPlugin,
   (copy) => {
     const ret = {
       patterns: []
@@ -5191,7 +5192,7 @@ var CopyRspackPlugin = create2(
 );
 
 // src/builtin-plugin/css-extract/index.ts
-var import_binding17 = require("@rspack/binding");
+var import_binding16 = require("@rspack/binding");
 var import_node_path3 = require("path");
 
 // src/builtin-plugin/css-extract/loader.ts
@@ -5227,7 +5228,7 @@ var CssExtractRspackPlugin = class {
       this.options.pathinfo = true;
     }
     compiler.__internal__registerBuiltinPlugin({
-      name: import_binding17.BuiltinPluginName.CssExtractRspackPlugin,
+      name: import_binding16.BuiltinPluginName.CssExtractRspackPlugin,
       options: this.normalizeOptions(this.options)
     });
   }
@@ -5285,27 +5286,27 @@ CssExtractRspackPlugin.pluginName = PLUGIN_NAME;
 CssExtractRspackPlugin.loader = LOADER_PATH;
 
 // src/builtin-plugin/CssModulesPlugin.ts
-var import_binding18 = require("@rspack/binding");
+var import_binding17 = require("@rspack/binding");
 var CssModulesPlugin = create2(
-  import_binding18.BuiltinPluginName.CssModulesPlugin,
+  import_binding17.BuiltinPluginName.CssModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/DataUriPlugin.ts
-var import_binding19 = require("@rspack/binding");
+var import_binding18 = require("@rspack/binding");
 var DataUriPlugin = create2(
-  import_binding19.BuiltinPluginName.DataUriPlugin,
+  import_binding18.BuiltinPluginName.DataUriPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/DefinePlugin.ts
-var import_binding20 = require("@rspack/binding");
+var import_binding19 = require("@rspack/binding");
 var DefinePlugin = create2(
-  import_binding20.BuiltinPluginName.DefinePlugin,
+  import_binding19.BuiltinPluginName.DefinePlugin,
   function(define) {
     var _a;
     const supportsBigIntLiteral = ((_a = this.options.output.environment) == null ? void 0 : _a.bigIntLiteral) ?? false;
@@ -5349,25 +5350,25 @@ var normalizeValue = (define, supportsBigIntLiteral) => {
 };
 
 // src/builtin-plugin/DeterministicChunkIdsPlugin.ts
-var import_binding21 = require("@rspack/binding");
+var import_binding20 = require("@rspack/binding");
 var DeterministicChunkIdsPlugin = create2(
-  import_binding21.BuiltinPluginName.DeterministicChunkIdsPlugin,
+  import_binding20.BuiltinPluginName.DeterministicChunkIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/DeterministicModuleIdsPlugin.ts
-var import_binding22 = require("@rspack/binding");
+var import_binding21 = require("@rspack/binding");
 var DeterministicModuleIdsPlugin = create2(
-  import_binding22.BuiltinPluginName.DeterministicModuleIdsPlugin,
+  import_binding21.BuiltinPluginName.DeterministicModuleIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/DynamicEntryPlugin.ts
-var import_binding26 = require("@rspack/binding");
+var import_binding25 = require("@rspack/binding");
 
 // src/lib/EntryOptionPlugin.ts
 var import_node_assert = __toESM(require("assert"));
@@ -5440,11 +5441,11 @@ var EntryOptionPlugin = class _EntryOptionPlugin {
 var EntryOptionPlugin_default = EntryOptionPlugin;
 
 // src/builtin-plugin/EntryPlugin.ts
-var import_binding25 = require("@rspack/binding");
+var import_binding24 = require("@rspack/binding");
 
 // src/config/adapter.ts
 var import_node_assert3 = __toESM(require("assert"));
-var import_binding24 = require("@rspack/binding");
+var import_binding23 = require("@rspack/binding");
 
 // src/util/identifier.ts
 var import_node_path4 = __toESM(require("path"));
@@ -5752,7 +5753,7 @@ function toFeatures(featureOptions) {
 var import_node_querystring = __toESM(require("querystring"));
 var import_node_assert2 = __toESM(require("assert"));
 var import_node_util3 = require("util");
-var import_binding23 = require("@rspack/binding");
+var import_binding22 = require("@rspack/binding");
 var import_webpack_sources2 = require("../compiled/webpack-sources/index.js");
 
 // src/NormalModule.ts
@@ -6347,7 +6348,7 @@ async function runLoaders(compiler, context2) {
     error.moduleIdentifier = this._module.identifier();
     compiler._lastCompilation.__internal__pushRspackDiagnostic({
       error,
-      severity: import_binding23.JsRspackSeverity.Error
+      severity: import_binding22.JsRspackSeverity.Error
     });
   };
   loaderContext.emitWarning = function emitWarning(warn) {
@@ -6363,7 +6364,7 @@ async function runLoaders(compiler, context2) {
     warning.moduleIdentifier = this._module.identifier();
     compiler._lastCompilation.__internal__pushRspackDiagnostic({
       error: warning,
-      severity: import_binding23.JsRspackSeverity.Warn
+      severity: import_binding22.JsRspackSeverity.Warn
     });
   };
   loaderContext.emitFile = function emitFile(name2, content, sourceMap, assetInfo) {
@@ -6404,7 +6405,7 @@ async function runLoaders(compiler, context2) {
         moduleIdentifier: context2._module.moduleIdentifier
       });
       compiler._lastCompilation.__internal__pushDiagnostic(
-        (0, import_binding23.formatDiagnostic)(d)
+        (0, import_binding22.formatDiagnostic)(d)
       );
     }
   };
@@ -6494,7 +6495,7 @@ async function runLoaders(compiler, context2) {
   });
   try {
     switch (loaderState) {
-      case import_binding23.JsLoaderState.Pitching: {
+      case import_binding22.JsLoaderState.Pitching: {
         while (loaderContext.loaderIndex < loaderContext.loaders.length) {
           const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
           if (currentLoaderObject.shouldYield()) break;
@@ -6522,7 +6523,7 @@ async function runLoaders(compiler, context2) {
         }
         break;
       }
-      case import_binding23.JsLoaderState.Normal: {
+      case import_binding22.JsLoaderState.Normal: {
         let content = context2.content;
         let sourceMap = JsSourceMap.__from_binding(context2.sourceMap);
         let additionalData = context2.additionalData;
@@ -7035,31 +7036,31 @@ var getRawModuleRule = (rule, path10, options, upperType) => {
 function getRawRuleSetCondition(condition) {
   if (typeof condition === "string") {
     return {
-      type: import_binding24.RawRuleSetConditionType.string,
+      type: import_binding23.RawRuleSetConditionType.string,
       string: condition
     };
   }
   if (condition instanceof RegExp) {
     return {
-      type: import_binding24.RawRuleSetConditionType.regexp,
+      type: import_binding23.RawRuleSetConditionType.regexp,
       regexp: condition
     };
   }
   if (typeof condition === "function") {
     return {
-      type: import_binding24.RawRuleSetConditionType.func,
+      type: import_binding23.RawRuleSetConditionType.func,
       func: condition
     };
   }
   if (Array.isArray(condition)) {
     return {
-      type: import_binding24.RawRuleSetConditionType.array,
+      type: import_binding23.RawRuleSetConditionType.array,
       array: condition.map((i) => getRawRuleSetCondition(i))
     };
   }
   if (typeof condition === "object" && condition !== null) {
     return {
-      type: import_binding24.RawRuleSetConditionType.logical,
+      type: import_binding23.RawRuleSetConditionType.logical,
       logical: [getRawRuleSetLogicalConditions(condition)]
     };
   }
@@ -7294,31 +7295,54 @@ function getRawSnapshotOptions(_snapshot) {
   return {};
 }
 function getRawExperiments(experiments3) {
-  const { topLevelAwait, layers, incremental: incremental2, rspackFuture } = experiments3;
+  const { topLevelAwait, layers, incremental: incremental2, rspackFuture, cache } = experiments3;
   (0, import_node_assert3.default)(
     !isNil(topLevelAwait) && !isNil(rspackFuture) && !isNil(layers) && !isNil(incremental2)
   );
   return {
     layers,
     topLevelAwait,
+    cache: getRawExperimentCache(cache),
     incremental: getRawIncremental(incremental2),
     rspackFuture: getRawRspackFutureOptions(rspackFuture)
   };
 }
+function getRawExperimentCache(cache) {
+  if (cache === void 0) {
+    throw new Error("experiment cache can not be undefined");
+  }
+  if (typeof cache === "boolean") {
+    return {
+      type: cache ? "memory" : "disable"
+    };
+  }
+  if (cache.type === "persistent") {
+    const { type, snapshot, storage } = cache;
+    return {
+      type,
+      snapshot,
+      storage: [storage]
+    };
+  }
+  return cache;
+}
 function getRawIncremental(incremental2) {
   if (incremental2 === false) {
     return void 0;
   }
   return {
     make: incremental2.make,
-    emitAssets: incremental2.emitAssets,
     inferAsyncModules: incremental2.inferAsyncModules,
     providedExports: incremental2.providedExports,
     dependenciesDiagnostics: incremental2.dependenciesDiagnostics,
+    buildChunkGraph: incremental2.buildChunkGraph,
     modulesHashes: incremental2.modulesHashes,
     modulesCodegen: incremental2.modulesCodegen,
     modulesRuntimeRequirements: incremental2.modulesRuntimeRequirements,
-    buildChunkGraph: incremental2.buildChunkGraph
+    chunksRuntimeRequirements: incremental2.chunksRuntimeRequirements,
+    chunksHashes: incremental2.chunksHashes,
+    chunksRender: incremental2.chunksRender,
+    emitAssets: incremental2.emitAssets
   };
 }
 function getRawRspackFutureOptions(future) {
@@ -8513,6 +8537,7 @@ var applyInfrastructureLoggingDefaults = (infrastructureLogging2) => {
   D(infrastructureLogging2, "appendOnly", !tty);
 };
 var applyExperimentsDefaults = (experiments3, { production }) => {
+  F(experiments3, "cache", () => !production);
   D(experiments3, "futureDefaults", false);
   D(experiments3, "lazyCompilation", false);
   D(experiments3, "asyncWebAssembly", experiments3.futureDefaults);
@@ -8529,6 +8554,9 @@ var applyExperimentsDefaults = (experiments3, { production }) => {
     D(experiments3.incremental, "modulesHashes", false);
     D(experiments3.incremental, "modulesCodegen", false);
     D(experiments3.incremental, "modulesRuntimeRequirements", false);
+    D(experiments3.incremental, "chunksRuntimeRequirements", false);
+    D(experiments3.incremental, "chunksHashes", false);
+    D(experiments3.incremental, "chunksRender", false);
     D(experiments3.incremental, "emitAssets", true);
   }
   D(experiments3, "rspackFuture", {});
@@ -9474,6 +9502,7 @@ var getNormalizedRspackOptions = (config2) => {
     plugins: nestedArray(config2.plugins, (p) => [...p]),
     experiments: nestedConfig(config2.experiments, (experiments3) => ({
       ...experiments3,
+      cache: experiments3.cache,
       lazyCompilation: optionalNestedConfig(
         experiments3.lazyCompilation,
         (options) => options === true ? {} : options
@@ -9482,14 +9511,17 @@ var getNormalizedRspackOptions = (config2) => {
         experiments3.incremental,
         (options) => options === true ? {
           make: true,
-          emitAssets: true,
           dependenciesDiagnostics: true,
           inferAsyncModules: true,
           providedExports: true,
+          buildChunkGraph: true,
           modulesHashes: true,
           modulesCodegen: true,
           modulesRuntimeRequirements: true,
-          buildChunkGraph: true
+          chunksRuntimeRequirements: true,
+          chunksHashes: true,
+          chunksRender: true,
+          emitAssets: true
         } : options
       )
     })),
@@ -9590,55 +9622,204 @@ var keyedNestedConfig = (value, fn2, customKeys) => {
 
 // src/config/zod.ts
 var import_node_path7 = __toESM(require("path"));
+var import_zod2 = require("../compiled/zod/index.js");
+
+// src/config/utils.ts
 var import_zod = require("../compiled/zod/index.js");
-var filenameTemplate = import_zod.z.string();
+function processCreateParams(params) {
+  if (!params) return {};
+  const { errorMap, invalid_type_error, required_error, description } = params;
+  if (errorMap && (invalid_type_error || required_error)) {
+    throw new Error(
+      `Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`
+    );
+  }
+  if (errorMap) return { errorMap, description };
+  const customMap = (iss, ctx) => {
+    const { message } = params;
+    if (iss.code === "invalid_enum_value") {
+      return { message: message ?? ctx.defaultError };
+    }
+    if (typeof ctx.data === "undefined") {
+      return { message: message ?? required_error ?? ctx.defaultError };
+    }
+    if (iss.code !== "invalid_type") return { message: ctx.defaultError };
+    return { message: message ?? invalid_type_error ?? ctx.defaultError };
+  };
+  return { errorMap: customMap, description };
+}
+var _RspackZodUnion = class _RspackZodUnion extends import_zod.z.ZodUnion {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const options = this._def.options;
+    function handleResults(results) {
+      for (const result2 of results) {
+        if (result2.result.status === "valid") {
+          return result2.result;
+        }
+      }
+      for (const result2 of results) {
+        if (result2.result.status === "dirty") {
+          ctx.common.issues.push(...result2.ctx.common.issues);
+          return result2.result;
+        }
+      }
+      const unionErrors2 = results.map(
+        (result2) => new import_zod.ZodError(result2.ctx.common.issues)
+      );
+      (0, import_zod.addIssueToContext)(ctx, {
+        code: import_zod.ZodIssueCode.invalid_union,
+        unionErrors: unionErrors2
+      });
+      return import_zod.INVALID;
+    }
+    if (ctx.common.async) {
+      return Promise.all(
+        options.map(async (option) => {
+          const childCtx = {
+            ...ctx,
+            common: {
+              ...ctx.common,
+              issues: []
+            },
+            parent: ctx
+          };
+          return {
+            result: await option._parseAsync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: childCtx
+            }),
+            ctx: childCtx
+          };
+        })
+      ).then(handleResults);
+    }
+    let dirty = void 0;
+    const issues = [];
+    for (const option of options) {
+      const childCtx = {
+        ...ctx,
+        common: {
+          ...ctx.common,
+          issues: []
+        },
+        parent: ctx
+      };
+      const result2 = option._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: childCtx
+      });
+      if (result2.status === "valid") {
+        return result2;
+      }
+      if (result2.status === "dirty" && !dirty) {
+        dirty = { result: result2, ctx: childCtx };
+      }
+      if (childCtx.common.issues.length) {
+        issues.push(childCtx.common.issues);
+      }
+    }
+    if (dirty) {
+      ctx.common.issues.push(...dirty.ctx.common.issues);
+      return dirty.result;
+    }
+    const unionErrors = issues.map((issues2) => new import_zod.ZodError(issues2));
+    (0, import_zod.addIssueToContext)(ctx, {
+      code: import_zod.ZodIssueCode.invalid_union,
+      unionErrors
+    });
+    return import_zod.INVALID;
+  }
+};
+_RspackZodUnion.create = (types, params) => {
+  return new _RspackZodUnion({
+    options: types,
+    typeName: import_zod.ZodFirstPartyTypeKind.ZodUnion,
+    ...processCreateParams(params)
+  });
+};
+var RspackZodUnion = _RspackZodUnion;
+import_zod.ZodUnion.create = RspackZodUnion.create;
+var ZodRspackCrossChecker = class extends import_zod.ZodType {
+  constructor(params) {
+    super(params);
+    this.params = params;
+  }
+  _parse(input) {
+    const ctx = this._getOrReturnCtx(input);
+    const root = this._getRootData(ctx);
+    for (const pattern of this.params.patterns) {
+      if (pattern.test(root)) {
+        const res = pattern.type._parse(input);
+        const issues = typeof pattern.issue === "function" ? pattern.issue(res) : [];
+        for (const issue of issues) {
+          (0, import_zod.addIssueToContext)(ctx, issue);
+        }
+        return res;
+      }
+    }
+    return this.params.default._parse(input);
+  }
+  _getRootData(ctx) {
+    let root = ctx;
+    while (root.parent) {
+      root = root.parent;
+    }
+    return root.data;
+  }
+};
+
+// src/config/zod.ts
+var filenameTemplate = import_zod2.z.string();
 var filename = filenameTemplate.or(
-  import_zod.z.function().args(import_zod.z.custom(), import_zod.z.custom().optional()).returns(import_zod.z.string())
+  import_zod2.z.function().args(import_zod2.z.custom(), import_zod2.z.custom().optional()).returns(import_zod2.z.string())
 );
-var name = import_zod.z.string();
-var dependencies = import_zod.z.array(name);
-var context = import_zod.z.string().refine(
+var name = import_zod2.z.string();
+var dependencies = import_zod2.z.array(name);
+var context = import_zod2.z.string().refine(
   (val) => import_node_path7.default.isAbsolute(val),
   (val) => ({
     message: `The provided value ${JSON.stringify(val)} must be an absolute path.`
   })
 );
-var mode = import_zod.z.enum([
+var mode = import_zod2.z.enum([
   "development",
   "production",
   "none"
 ]);
-var falsy = import_zod.z.union([
-  import_zod.z.literal(false),
-  import_zod.z.literal(0),
-  import_zod.z.literal(""),
-  import_zod.z.null(),
-  import_zod.z.undefined()
+var falsy = import_zod2.z.union([
+  import_zod2.z.literal(false),
+  import_zod2.z.literal(0),
+  import_zod2.z.literal(""),
+  import_zod2.z.null(),
+  import_zod2.z.undefined()
 ]);
-var publicPath = import_zod.z.literal("auto").or(filename);
-var baseUri = import_zod.z.string();
-var chunkLoadingType = import_zod.z.enum(["jsonp", "import-scripts", "require", "async-node", "import"]).or(import_zod.z.string());
-var chunkLoading = import_zod.z.literal(false).or(chunkLoadingType);
-var asyncChunks = import_zod.z.boolean();
-var wasmLoadingType = import_zod.z.enum(["fetch-streaming", "fetch", "async-node"]).or(import_zod.z.string());
-var wasmLoading = import_zod.z.literal(false).or(wasmLoadingType);
-var scriptType = import_zod.z.enum(["text/javascript", "module"]).or(import_zod.z.literal(false));
-var libraryCustomUmdObject = import_zod.z.strictObject({
-  amd: import_zod.z.string().optional(),
-  commonjs: import_zod.z.string().optional(),
-  root: import_zod.z.string().or(import_zod.z.array(import_zod.z.string())).optional()
+var publicPath = import_zod2.z.literal("auto").or(filename);
+var baseUri = import_zod2.z.string();
+var chunkLoadingType = import_zod2.z.enum(["jsonp", "import-scripts", "require", "async-node", "import"]).or(import_zod2.z.string());
+var chunkLoading = import_zod2.z.literal(false).or(chunkLoadingType);
+var asyncChunks = import_zod2.z.boolean();
+var wasmLoadingType = import_zod2.z.enum(["fetch-streaming", "fetch", "async-node"]).or(import_zod2.z.string());
+var wasmLoading = import_zod2.z.literal(false).or(wasmLoadingType);
+var scriptType = import_zod2.z.enum(["text/javascript", "module"]).or(import_zod2.z.literal(false));
+var libraryCustomUmdObject = import_zod2.z.strictObject({
+  amd: import_zod2.z.string().optional(),
+  commonjs: import_zod2.z.string().optional(),
+  root: import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string())).optional()
 });
-var libraryName = import_zod.z.string().or(import_zod.z.array(import_zod.z.string())).or(libraryCustomUmdObject);
-var libraryCustomUmdCommentObject = import_zod.z.strictObject({
-  amd: import_zod.z.string().optional(),
-  commonjs: import_zod.z.string().optional(),
-  commonjs2: import_zod.z.string().optional(),
-  root: import_zod.z.string().optional()
+var libraryName = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string())).or(libraryCustomUmdObject);
+var libraryCustomUmdCommentObject = import_zod2.z.strictObject({
+  amd: import_zod2.z.string().optional(),
+  commonjs: import_zod2.z.string().optional(),
+  commonjs2: import_zod2.z.string().optional(),
+  root: import_zod2.z.string().optional()
 });
-var amdContainer = import_zod.z.string();
-var auxiliaryComment = import_zod.z.string().or(libraryCustomUmdCommentObject);
-var libraryExport = import_zod.z.string().or(import_zod.z.array(import_zod.z.string()));
-var libraryType = import_zod.z.enum([
+var amdContainer = import_zod2.z.string();
+var auxiliaryComment = import_zod2.z.string().or(libraryCustomUmdCommentObject);
+var libraryExport = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()));
+var libraryType = import_zod2.z.enum([
   "var",
   "module",
   "assign",
@@ -9657,9 +9838,9 @@ var libraryType = import_zod.z.enum([
   "umd2",
   "jsonp",
   "system"
-]).or(import_zod.z.string());
-var umdNamedDefine = import_zod.z.boolean();
-var libraryOptions = import_zod.z.strictObject({
+]).or(import_zod2.z.string());
+var umdNamedDefine = import_zod2.z.boolean();
+var libraryOptions = import_zod2.z.strictObject({
   amdContainer: amdContainer.optional(),
   auxiliaryComment: auxiliaryComment.optional(),
   export: libraryExport.optional(),
@@ -9668,12 +9849,12 @@ var libraryOptions = import_zod.z.strictObject({
   umdNamedDefine: umdNamedDefine.optional()
 });
 var library = libraryName.or(libraryOptions).optional();
-var layer = import_zod.z.string().or(import_zod.z.null());
+var layer = import_zod2.z.string().or(import_zod2.z.null());
 var entryFilename = filename;
-var entryRuntime = import_zod.z.literal(false).or(import_zod.z.string());
-var entryItem = import_zod.z.string().or(import_zod.z.array(import_zod.z.string()));
-var entryDependOn = import_zod.z.string().or(import_zod.z.array(import_zod.z.string()));
-var entryDescription = import_zod.z.strictObject({
+var entryRuntime = import_zod2.z.literal(false).or(import_zod2.z.string());
+var entryItem = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()));
+var entryDependOn = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()));
+var entryDescription = import_zod2.z.strictObject({
   import: entryItem,
   runtime: entryRuntime.optional(),
   publicPath: publicPath.optional(),
@@ -9687,84 +9868,84 @@ var entryDescription = import_zod.z.strictObject({
   layer: layer.optional()
 });
 var entryUnnamed = entryItem;
-var entryObject = import_zod.z.record(
+var entryObject = import_zod2.z.record(
   entryItem.or(entryDescription)
 );
 var entryStatic = entryObject.or(
   entryUnnamed
 );
-var entryDynamic = import_zod.z.function().returns(
-  entryStatic.or(import_zod.z.promise(entryStatic))
+var entryDynamic = import_zod2.z.function().returns(
+  entryStatic.or(import_zod2.z.promise(entryStatic))
 );
 var entry = entryStatic.or(entryDynamic);
-var path6 = import_zod.z.string();
-var pathinfo = import_zod.z.boolean().or(import_zod.z.literal("verbose"));
+var path6 = import_zod2.z.string();
+var pathinfo = import_zod2.z.boolean().or(import_zod2.z.literal("verbose"));
 var assetModuleFilename = filename;
-var webassemblyModuleFilename = import_zod.z.string();
+var webassemblyModuleFilename = import_zod2.z.string();
 var chunkFilename = filename;
-var crossOriginLoading = import_zod.z.literal(false).or(
-  import_zod.z.enum(["anonymous", "use-credentials"])
+var crossOriginLoading = import_zod2.z.literal(false).or(
+  import_zod2.z.enum(["anonymous", "use-credentials"])
 );
 var cssFilename = filename;
 var cssChunkFilename = filename;
 var hotUpdateChunkFilename = filenameTemplate;
 var hotUpdateMainFilename = filenameTemplate;
-var hotUpdateGlobal = import_zod.z.string();
-var uniqueName = import_zod.z.string();
-var chunkLoadingGlobal = import_zod.z.string();
-var enabledLibraryTypes = import_zod.z.array(
+var hotUpdateGlobal = import_zod2.z.string();
+var uniqueName = import_zod2.z.string();
+var chunkLoadingGlobal = import_zod2.z.string();
+var enabledLibraryTypes = import_zod2.z.array(
   libraryType
 );
-var clean = import_zod.z.boolean();
-var outputModule = import_zod.z.boolean();
-var strictModuleExceptionHandling = import_zod.z.boolean();
-var strictModuleErrorHandling = import_zod.z.boolean();
-var globalObject = import_zod.z.string();
-var enabledWasmLoadingTypes = import_zod.z.array(
+var clean = import_zod2.z.boolean();
+var outputModule = import_zod2.z.boolean();
+var strictModuleExceptionHandling = import_zod2.z.boolean();
+var strictModuleErrorHandling = import_zod2.z.boolean();
+var globalObject = import_zod2.z.string();
+var enabledWasmLoadingTypes = import_zod2.z.array(
   wasmLoadingType
 );
-var importFunctionName = import_zod.z.string();
-var importMetaName = import_zod.z.string();
-var iife = import_zod.z.boolean();
-var enabledChunkLoadingTypes = import_zod.z.array(
+var importFunctionName = import_zod2.z.string();
+var importMetaName = import_zod2.z.string();
+var iife = import_zod2.z.boolean();
+var enabledChunkLoadingTypes = import_zod2.z.array(
   chunkLoadingType
 );
-var chunkFormat = import_zod.z.literal(false).or(import_zod.z.string());
-var workerPublicPath = import_zod.z.string();
-var trustedTypes = import_zod.z.strictObject({
-  policyName: import_zod.z.string().optional()
+var chunkFormat = import_zod2.z.literal(false).or(import_zod2.z.string());
+var workerPublicPath = import_zod2.z.string();
+var trustedTypes = import_zod2.z.strictObject({
+  policyName: import_zod2.z.string().optional()
 });
-var hashDigest = import_zod.z.string();
-var hashDigestLength = import_zod.z.number();
-var hashFunction = import_zod.z.enum([
+var hashDigest = import_zod2.z.string();
+var hashDigestLength = import_zod2.z.number();
+var hashFunction = import_zod2.z.enum([
   "md4",
   "xxhash64"
 ]);
-var hashSalt = import_zod.z.string();
-var sourceMapFilename = import_zod.z.string();
-var devtoolNamespace = import_zod.z.string();
-var devtoolModuleFilenameTemplate = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.function(import_zod.z.tuple([import_zod.z.any()]), import_zod.z.any())
+var hashSalt = import_zod2.z.string();
+var sourceMapFilename = import_zod2.z.string();
+var devtoolNamespace = import_zod2.z.string();
+var devtoolModuleFilenameTemplate = import_zod2.z.union([
+  import_zod2.z.string(),
+  import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.any()]), import_zod2.z.any())
 ]);
 var devtoolFallbackModuleFilenameTemplate = devtoolModuleFilenameTemplate;
-var environment = import_zod.z.strictObject({
-  arrowFunction: import_zod.z.boolean().optional(),
-  asyncFunction: import_zod.z.boolean().optional(),
-  bigIntLiteral: import_zod.z.boolean().optional(),
-  const: import_zod.z.boolean().optional(),
-  destructuring: import_zod.z.boolean().optional(),
-  document: import_zod.z.boolean().optional(),
-  dynamicImport: import_zod.z.boolean().optional(),
-  dynamicImportInWorker: import_zod.z.boolean().optional(),
-  forOf: import_zod.z.boolean().optional(),
-  globalThis: import_zod.z.boolean().optional(),
-  module: import_zod.z.boolean().optional(),
-  nodePrefixForCoreModules: import_zod.z.boolean().optional(),
-  optionalChaining: import_zod.z.boolean().optional(),
-  templateLiteral: import_zod.z.boolean().optional()
+var environment = import_zod2.z.strictObject({
+  arrowFunction: import_zod2.z.boolean().optional(),
+  asyncFunction: import_zod2.z.boolean().optional(),
+  bigIntLiteral: import_zod2.z.boolean().optional(),
+  const: import_zod2.z.boolean().optional(),
+  destructuring: import_zod2.z.boolean().optional(),
+  document: import_zod2.z.boolean().optional(),
+  dynamicImport: import_zod2.z.boolean().optional(),
+  dynamicImportInWorker: import_zod2.z.boolean().optional(),
+  forOf: import_zod2.z.boolean().optional(),
+  globalThis: import_zod2.z.boolean().optional(),
+  module: import_zod2.z.boolean().optional(),
+  nodePrefixForCoreModules: import_zod2.z.boolean().optional(),
+  optionalChaining: import_zod2.z.boolean().optional(),
+  templateLiteral: import_zod2.z.boolean().optional()
 });
-var output = import_zod.z.strictObject({
+var output = import_zod2.z.strictObject({
   path: path6.optional(),
   pathinfo: pathinfo.optional(),
   clean: clean.optional(),
@@ -9773,7 +9954,7 @@ var output = import_zod.z.strictObject({
   chunkFilename: chunkFilename.optional(),
   crossOriginLoading: crossOriginLoading.optional(),
   cssFilename: cssFilename.optional(),
-  cssHeadDataCompression: import_zod.z.boolean().optional(),
+  cssHeadDataCompression: import_zod2.z.boolean().optional(),
   cssChunkFilename: cssChunkFilename.optional(),
   hotUpdateMainFilename: hotUpdateMainFilename.optional(),
   hotUpdateChunkFilename: hotUpdateChunkFilename.optional(),
@@ -9800,7 +9981,7 @@ var output = import_zod.z.strictObject({
   chunkFormat: chunkFormat.optional(),
   chunkLoading: chunkLoading.optional(),
   enabledChunkLoadingTypes: enabledChunkLoadingTypes.optional(),
-  trustedTypes: import_zod.z.literal(true).or(import_zod.z.string()).or(trustedTypes).optional(),
+  trustedTypes: import_zod2.z.literal(true).or(import_zod2.z.string()).or(trustedTypes).optional(),
   sourceMapFilename: sourceMapFilename.optional(),
   hashDigest: hashDigest.optional(),
   hashDigestLength: hashDigestLength.optional(),
@@ -9814,60 +9995,60 @@ var output = import_zod.z.strictObject({
   devtoolNamespace: devtoolNamespace.optional(),
   devtoolModuleFilenameTemplate: devtoolModuleFilenameTemplate.optional(),
   devtoolFallbackModuleFilenameTemplate: devtoolFallbackModuleFilenameTemplate.optional(),
-  chunkLoadTimeout: import_zod.z.number().optional(),
-  charset: import_zod.z.boolean().optional(),
+  chunkLoadTimeout: import_zod2.z.number().optional(),
+  charset: import_zod2.z.boolean().optional(),
   environment: environment.optional(),
-  compareBeforeEmit: import_zod.z.boolean().optional()
+  compareBeforeEmit: import_zod2.z.boolean().optional()
 });
-var resolveAlias = import_zod.z.record(
-  import_zod.z.literal(false).or(import_zod.z.string()).or(import_zod.z.array(import_zod.z.string().or(import_zod.z.literal(false))))
+var resolveAlias = import_zod2.z.record(
+  import_zod2.z.literal(false).or(import_zod2.z.string()).or(import_zod2.z.array(import_zod2.z.string().or(import_zod2.z.literal(false))))
 );
-var resolveTsConfigFile = import_zod.z.string();
+var resolveTsConfigFile = import_zod2.z.string();
 var resolveTsConfig = resolveTsConfigFile.or(
-  import_zod.z.strictObject({
+  import_zod2.z.strictObject({
     configFile: resolveTsConfigFile,
-    references: import_zod.z.array(import_zod.z.string()).or(import_zod.z.literal("auto")).optional()
+    references: import_zod2.z.array(import_zod2.z.string()).or(import_zod2.z.literal("auto")).optional()
   })
 );
-var baseResolveOptions = import_zod.z.strictObject({
+var baseResolveOptions = import_zod2.z.strictObject({
   alias: resolveAlias.optional(),
-  conditionNames: import_zod.z.array(import_zod.z.string()).optional(),
-  extensions: import_zod.z.array(import_zod.z.string()).optional(),
+  conditionNames: import_zod2.z.array(import_zod2.z.string()).optional(),
+  extensions: import_zod2.z.array(import_zod2.z.string()).optional(),
   fallback: resolveAlias.optional(),
-  mainFields: import_zod.z.array(import_zod.z.string()).optional(),
-  mainFiles: import_zod.z.array(import_zod.z.string()).optional(),
-  modules: import_zod.z.array(import_zod.z.string()).optional(),
-  preferRelative: import_zod.z.boolean().optional(),
-  preferAbsolute: import_zod.z.boolean().optional(),
-  symlinks: import_zod.z.boolean().optional(),
-  enforceExtension: import_zod.z.boolean().optional(),
-  importsFields: import_zod.z.array(import_zod.z.string()).optional(),
-  descriptionFiles: import_zod.z.array(import_zod.z.string()).optional(),
+  mainFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  mainFiles: import_zod2.z.array(import_zod2.z.string()).optional(),
+  modules: import_zod2.z.array(import_zod2.z.string()).optional(),
+  preferRelative: import_zod2.z.boolean().optional(),
+  preferAbsolute: import_zod2.z.boolean().optional(),
+  symlinks: import_zod2.z.boolean().optional(),
+  enforceExtension: import_zod2.z.boolean().optional(),
+  importsFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  descriptionFiles: import_zod2.z.array(import_zod2.z.string()).optional(),
   tsConfig: resolveTsConfig.optional(),
-  fullySpecified: import_zod.z.boolean().optional(),
-  exportsFields: import_zod.z.array(import_zod.z.string()).optional(),
-  extensionAlias: import_zod.z.record(import_zod.z.string().or(import_zod.z.array(import_zod.z.string()))).optional(),
-  aliasFields: import_zod.z.array(import_zod.z.string()).optional(),
-  restrictions: import_zod.z.array(import_zod.z.string()).optional(),
-  roots: import_zod.z.array(import_zod.z.string()).optional()
+  fullySpecified: import_zod2.z.boolean().optional(),
+  exportsFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  extensionAlias: import_zod2.z.record(import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()))).optional(),
+  aliasFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  restrictions: import_zod2.z.array(import_zod2.z.string()).optional(),
+  roots: import_zod2.z.array(import_zod2.z.string()).optional()
 });
 var resolveOptions = baseResolveOptions.extend({
-  byDependency: import_zod.z.lazy(() => import_zod.z.record(resolveOptions)).optional()
+  byDependency: import_zod2.z.lazy(() => import_zod2.z.record(resolveOptions)).optional()
 });
-var baseRuleSetCondition = import_zod.z.instanceof(RegExp).or(import_zod.z.string()).or(import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()));
-var ruleSetCondition = baseRuleSetCondition.or(import_zod.z.lazy(() => ruleSetConditions)).or(import_zod.z.lazy(() => ruleSetLogicalConditions));
-var ruleSetConditions = import_zod.z.lazy(
-  () => import_zod.z.array(ruleSetCondition)
+var baseRuleSetCondition = import_zod2.z.instanceof(RegExp).or(import_zod2.z.string()).or(import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean()));
+var ruleSetCondition = baseRuleSetCondition.or(import_zod2.z.lazy(() => ruleSetConditions)).or(import_zod2.z.lazy(() => ruleSetLogicalConditions));
+var ruleSetConditions = import_zod2.z.lazy(
+  () => import_zod2.z.array(ruleSetCondition)
 );
-var ruleSetLogicalConditions = import_zod.z.strictObject({
+var ruleSetLogicalConditions = import_zod2.z.strictObject({
   and: ruleSetConditions.optional(),
   or: ruleSetConditions.optional(),
   not: ruleSetCondition.optional()
 });
-var ruleSetLoader = import_zod.z.string();
-var ruleSetLoaderOptions = import_zod.z.string().or(import_zod.z.record(import_zod.z.any()));
-var ruleSetLoaderWithOptions = import_zod.z.strictObject({
-  ident: import_zod.z.string().optional(),
+var ruleSetLoader = import_zod2.z.string();
+var ruleSetLoaderOptions = import_zod2.z.string().or(import_zod2.z.record(import_zod2.z.any()));
+var ruleSetLoaderWithOptions = import_zod2.z.strictObject({
+  ident: import_zod2.z.string().optional(),
   loader: ruleSetLoader,
   options: ruleSetLoaderOptions.optional()
 });
@@ -9875,9 +10056,9 @@ var ruleSetUseItem = ruleSetLoader.or(
   ruleSetLoaderWithOptions
 );
 var ruleSetUse = ruleSetUseItem.or(ruleSetUseItem.array()).or(
-  import_zod.z.function().args(import_zod.z.custom()).returns(ruleSetUseItem.array())
+  import_zod2.z.function().args(import_zod2.z.custom()).returns(ruleSetUseItem.array())
 );
-var baseRuleSetRule = import_zod.z.strictObject({
+var baseRuleSetRule = import_zod2.z.strictObject({
   test: ruleSetCondition.optional(),
   exclude: ruleSetCondition.optional(),
   include: ruleSetCondition.optional(),
@@ -9889,67 +10070,67 @@ var baseRuleSetRule = import_zod.z.strictObject({
   resourceQuery: ruleSetCondition.optional(),
   scheme: ruleSetCondition.optional(),
   mimetype: ruleSetCondition.optional(),
-  descriptionData: import_zod.z.record(ruleSetCondition).optional(),
-  with: import_zod.z.record(ruleSetCondition).optional(),
-  type: import_zod.z.string().optional(),
-  layer: import_zod.z.string().optional(),
+  descriptionData: import_zod2.z.record(ruleSetCondition).optional(),
+  with: import_zod2.z.record(ruleSetCondition).optional(),
+  type: import_zod2.z.string().optional(),
+  layer: import_zod2.z.string().optional(),
   loader: ruleSetLoader.optional(),
   options: ruleSetLoaderOptions.optional(),
   use: ruleSetUse.optional(),
-  parser: import_zod.z.record(import_zod.z.any()).optional(),
-  generator: import_zod.z.record(import_zod.z.any()).optional(),
+  parser: import_zod2.z.record(import_zod2.z.any()).optional(),
+  generator: import_zod2.z.record(import_zod2.z.any()).optional(),
   resolve: resolveOptions.optional(),
-  sideEffects: import_zod.z.boolean().optional(),
-  enforce: import_zod.z.literal("pre").or(import_zod.z.literal("post")).optional()
+  sideEffects: import_zod2.z.boolean().optional(),
+  enforce: import_zod2.z.literal("pre").or(import_zod2.z.literal("post")).optional()
 });
 var ruleSetRule = baseRuleSetRule.extend({
-  oneOf: import_zod.z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
-  rules: import_zod.z.lazy(() => ruleSetRule.or(falsy).array()).optional()
+  oneOf: import_zod2.z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
+  rules: import_zod2.z.lazy(() => ruleSetRule.or(falsy).array()).optional()
 });
-var ruleSetRules = import_zod.z.array(
-  import_zod.z.literal("...").or(ruleSetRule).or(falsy)
+var ruleSetRules = import_zod2.z.array(
+  import_zod2.z.literal("...").or(ruleSetRule).or(falsy)
 );
-var assetParserDataUrlOptions = import_zod.z.strictObject({
-  maxSize: import_zod.z.number().optional()
+var assetParserDataUrlOptions = import_zod2.z.strictObject({
+  maxSize: import_zod2.z.number().optional()
 });
 var assetParserDataUrl = assetParserDataUrlOptions;
-var assetParserOptions = import_zod.z.strictObject({
+var assetParserOptions = import_zod2.z.strictObject({
   dataUrlCondition: assetParserDataUrl.optional()
 });
-var cssParserNamedExports = import_zod.z.boolean();
-var cssParserOptions = import_zod.z.strictObject({
+var cssParserNamedExports = import_zod2.z.boolean();
+var cssParserOptions = import_zod2.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var cssAutoParserOptions = import_zod.z.strictObject({
+var cssAutoParserOptions = import_zod2.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var cssModuleParserOptions = import_zod.z.strictObject({
+var cssModuleParserOptions = import_zod2.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var dynamicImportMode = import_zod.z.enum(["eager", "lazy", "weak", "lazy-once"]);
-var dynamicImportPreload = import_zod.z.union([import_zod.z.boolean(), import_zod.z.number()]);
-var dynamicImportPrefetch = import_zod.z.union([import_zod.z.boolean(), import_zod.z.number()]);
-var dynamicImportFetchPriority = import_zod.z.enum(["low", "high", "auto"]);
-var javascriptParserUrl = import_zod.z.union([import_zod.z.literal("relative"), import_zod.z.boolean()]);
-var exprContextCritical = import_zod.z.boolean();
-var wrappedContextCritical = import_zod.z.boolean();
-var wrappedContextRegExp = import_zod.z.instanceof(RegExp);
-var exportsPresence = import_zod.z.enum(["error", "warn", "auto"]).or(import_zod.z.literal(false));
-var importExportsPresence = import_zod.z.enum(["error", "warn", "auto"]).or(import_zod.z.literal(false));
-var reexportExportsPresence = import_zod.z.enum(["error", "warn", "auto"]).or(import_zod.z.literal(false));
-var strictExportPresence = import_zod.z.boolean();
-var worker = import_zod.z.array(import_zod.z.string()).or(import_zod.z.boolean());
-var overrideStrict = import_zod.z.enum(["strict", "non-strict"]);
-var requireAsExpression = import_zod.z.boolean();
-var requireDynamic = import_zod.z.boolean();
-var requireResolve = import_zod.z.boolean();
-var importDynamic = import_zod.z.boolean();
-var javascriptParserOptions = import_zod.z.strictObject({
+var dynamicImportMode = import_zod2.z.enum(["eager", "lazy", "weak", "lazy-once"]);
+var dynamicImportPreload = import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number()]);
+var dynamicImportPrefetch = import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number()]);
+var dynamicImportFetchPriority = import_zod2.z.enum(["low", "high", "auto"]);
+var javascriptParserUrl = import_zod2.z.union([import_zod2.z.literal("relative"), import_zod2.z.boolean()]);
+var exprContextCritical = import_zod2.z.boolean();
+var wrappedContextCritical = import_zod2.z.boolean();
+var wrappedContextRegExp = import_zod2.z.instanceof(RegExp);
+var exportsPresence = import_zod2.z.enum(["error", "warn", "auto"]).or(import_zod2.z.literal(false));
+var importExportsPresence = import_zod2.z.enum(["error", "warn", "auto"]).or(import_zod2.z.literal(false));
+var reexportExportsPresence = import_zod2.z.enum(["error", "warn", "auto"]).or(import_zod2.z.literal(false));
+var strictExportPresence = import_zod2.z.boolean();
+var worker = import_zod2.z.array(import_zod2.z.string()).or(import_zod2.z.boolean());
+var overrideStrict = import_zod2.z.enum(["strict", "non-strict"]);
+var requireAsExpression = import_zod2.z.boolean();
+var requireDynamic = import_zod2.z.boolean();
+var requireResolve = import_zod2.z.boolean();
+var importDynamic = import_zod2.z.boolean();
+var javascriptParserOptions = import_zod2.z.strictObject({
   dynamicImportMode: dynamicImportMode.optional(),
   dynamicImportPreload: dynamicImportPreload.optional(),
   dynamicImportPrefetch: dynamicImportPrefetch.optional(),
   dynamicImportFetchPriority: dynamicImportFetchPriority.optional(),
-  importMeta: import_zod.z.boolean().optional(),
+  importMeta: import_zod2.z.boolean().optional(),
   url: javascriptParserUrl.optional(),
   exprContextCritical: exprContextCritical.optional(),
   wrappedContextCritical: wrappedContextCritical.optional(),
@@ -9967,7 +10148,7 @@ var javascriptParserOptions = import_zod.z.strictObject({
   importDynamic: importDynamic.optional()
   // #endregion
 });
-var parserOptionsByModuleTypeKnown = import_zod.z.strictObject({
+var parserOptionsByModuleTypeKnown = import_zod2.z.strictObject({
   asset: assetParserOptions.optional(),
   css: cssParserOptions.optional(),
   "css/auto": cssAutoParserOptions.optional(),
@@ -9977,63 +10158,63 @@ var parserOptionsByModuleTypeKnown = import_zod.z.strictObject({
   "javascript/dynamic": javascriptParserOptions.optional(),
   "javascript/esm": javascriptParserOptions.optional()
 });
-var parserOptionsByModuleTypeUnknown = import_zod.z.record(
-  import_zod.z.record(import_zod.z.any())
+var parserOptionsByModuleTypeUnknown = import_zod2.z.record(
+  import_zod2.z.record(import_zod2.z.any())
 );
 var parserOptionsByModuleType = parserOptionsByModuleTypeKnown.or(
   parserOptionsByModuleTypeUnknown
 );
-var assetGeneratorDataUrlOptions = import_zod.z.strictObject({
-  encoding: import_zod.z.literal(false).or(import_zod.z.literal("base64")).optional(),
-  mimetype: import_zod.z.string().optional()
+var assetGeneratorDataUrlOptions = import_zod2.z.strictObject({
+  encoding: import_zod2.z.literal(false).or(import_zod2.z.literal("base64")).optional(),
+  mimetype: import_zod2.z.string().optional()
 });
-var assetGeneratorDataUrlFunction = import_zod.z.function().args(
-  import_zod.z.strictObject({
-    content: import_zod.z.string(),
-    filename: import_zod.z.string()
+var assetGeneratorDataUrlFunction = import_zod2.z.function().args(
+  import_zod2.z.strictObject({
+    content: import_zod2.z.string(),
+    filename: import_zod2.z.string()
   })
-).returns(import_zod.z.string());
+).returns(import_zod2.z.string());
 var assetGeneratorDataUrl = assetGeneratorDataUrlOptions.or(
   assetGeneratorDataUrlFunction
 );
-var assetInlineGeneratorOptions = import_zod.z.strictObject({
+var assetInlineGeneratorOptions = import_zod2.z.strictObject({
   dataUrl: assetGeneratorDataUrl.optional()
 });
-var assetResourceGeneratorOptions = import_zod.z.strictObject({
-  emit: import_zod.z.boolean().optional(),
+var assetResourceGeneratorOptions = import_zod2.z.strictObject({
+  emit: import_zod2.z.boolean().optional(),
   filename: filename.optional(),
   publicPath: publicPath.optional()
 });
 var assetGeneratorOptions = assetInlineGeneratorOptions.merge(
   assetResourceGeneratorOptions
 );
-var cssGeneratorExportsConvention = import_zod.z.enum([
+var cssGeneratorExportsConvention = import_zod2.z.enum([
   "as-is",
   "camel-case",
   "camel-case-only",
   "dashes",
   "dashes-only"
 ]);
-var cssGeneratorExportsOnly = import_zod.z.boolean();
-var cssGeneratorLocalIdentName = import_zod.z.string();
-var cssGeneratorEsModule = import_zod.z.boolean();
-var cssGeneratorOptions = import_zod.z.strictObject({
+var cssGeneratorExportsOnly = import_zod2.z.boolean();
+var cssGeneratorLocalIdentName = import_zod2.z.string();
+var cssGeneratorEsModule = import_zod2.z.boolean();
+var cssGeneratorOptions = import_zod2.z.strictObject({
   exportsOnly: cssGeneratorExportsOnly.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var cssAutoGeneratorOptions = import_zod.z.strictObject({
+var cssAutoGeneratorOptions = import_zod2.z.strictObject({
   exportsConvention: cssGeneratorExportsConvention.optional(),
   exportsOnly: cssGeneratorExportsOnly.optional(),
   localIdentName: cssGeneratorLocalIdentName.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var cssModuleGeneratorOptions = import_zod.z.strictObject({
+var cssModuleGeneratorOptions = import_zod2.z.strictObject({
   exportsConvention: cssGeneratorExportsConvention.optional(),
   exportsOnly: cssGeneratorExportsOnly.optional(),
   localIdentName: cssGeneratorLocalIdentName.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var generatorOptionsByModuleTypeKnown = import_zod.z.strictObject({
+var generatorOptionsByModuleTypeKnown = import_zod2.z.strictObject({
   asset: assetGeneratorOptions.optional(),
   "asset/inline": assetInlineGeneratorOptions.optional(),
   "asset/resource": assetResourceGeneratorOptions.optional(),
@@ -10041,25 +10222,25 @@ var generatorOptionsByModuleTypeKnown = import_zod.z.strictObject({
   "css/auto": cssAutoGeneratorOptions.optional(),
   "css/module": cssModuleGeneratorOptions.optional()
 });
-var generatorOptionsByModuleTypeUnknown = import_zod.z.record(
-  import_zod.z.record(import_zod.z.any())
+var generatorOptionsByModuleTypeUnknown = import_zod2.z.record(
+  import_zod2.z.record(import_zod2.z.any())
 );
 var generatorOptionsByModuleType = generatorOptionsByModuleTypeKnown.or(
   generatorOptionsByModuleTypeUnknown
 );
-var noParseOptionSingle = import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()));
+var noParseOptionSingle = import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean()));
 var noParseOption = noParseOptionSingle.or(
-  import_zod.z.array(noParseOptionSingle)
+  import_zod2.z.array(noParseOptionSingle)
 );
-var moduleOptions = import_zod.z.strictObject({
+var moduleOptions = import_zod2.z.strictObject({
   defaultRules: ruleSetRules.optional(),
   rules: ruleSetRules.optional(),
   parser: parserOptionsByModuleType.optional(),
   generator: generatorOptionsByModuleType.optional(),
   noParse: noParseOption.optional()
 });
-var allowTarget = import_zod.z.union([
-  import_zod.z.enum([
+var allowTarget = import_zod2.z.union([
+  import_zod2.z.enum([
     "web",
     "webworker",
     "es3",
@@ -10073,66 +10254,66 @@ var allowTarget = import_zod.z.union([
     "es2021",
     "es2022"
   ]),
-  import_zod.z.literal("node"),
-  import_zod.z.literal("async-node"),
-  import_zod.z.custom(
+  import_zod2.z.literal("node"),
+  import_zod2.z.literal("async-node"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^async-node\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node\d+\.\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^async-node\d+\.\d+$/.test(value)
   ),
-  import_zod.z.literal("electron-main"),
-  import_zod.z.custom(
+  import_zod2.z.literal("electron-main"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+-main$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-main$/.test(value)
   ),
-  import_zod.z.literal("electron-renderer"),
-  import_zod.z.custom(
+  import_zod2.z.literal("electron-renderer"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+-renderer$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-renderer$/.test(value)
   ),
-  import_zod.z.literal("electron-preload"),
-  import_zod.z.custom(
+  import_zod2.z.literal("electron-preload"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+-preload$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-preload$/.test(value)
   ),
-  import_zod.z.literal("nwjs"),
-  import_zod.z.custom(
+  import_zod2.z.literal("nwjs"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^nwjs\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^nwjs\d+\.\d+$/.test(value)
   ),
-  import_zod.z.literal("node-webkit"),
-  import_zod.z.custom(
+  import_zod2.z.literal("node-webkit"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node-webkit\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node-webkit\d+\.\d+$/.test(value)
   ),
-  import_zod.z.literal("browserslist"),
-  import_zod.z.custom(
+  import_zod2.z.literal("browserslist"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^browserslist:(.+)$/.test(value)
   )
 ]);
-var target = import_zod.z.union([
-  import_zod.z.literal(false),
+var target = import_zod2.z.union([
+  import_zod2.z.literal(false),
   allowTarget,
   allowTarget.array()
 ]);
-var externalsType = import_zod.z.enum([
+var externalsType = import_zod2.z.enum([
   "var",
   "module",
   "assign",
@@ -10154,64 +10335,97 @@ var externalsType = import_zod.z.enum([
   "import",
   "module-import",
   "script",
-  "node-commonjs"
+  "node-commonjs",
+  "commonjs-import"
 ]);
-var externalItemValue = import_zod.z.string().or(import_zod.z.boolean()).or(import_zod.z.string().array().min(1)).or(
-  import_zod.z.strictObject({
-    root: import_zod.z.string().or(import_zod.z.string().array()),
-    commonjs: import_zod.z.string().or(import_zod.z.string().array()),
-    commonjs2: import_zod.z.string().or(import_zod.z.string().array()),
-    amd: import_zod.z.string().or(import_zod.z.string().array()).optional()
-  })
-);
-var externalItemObjectUnknown = import_zod.z.record(
+var ZodExternalObjectValue = new ZodRspackCrossChecker({
+  patterns: [
+    {
+      test: (config2) => {
+        var _a, _b;
+        let isLibraryUmd = false;
+        const library3 = (_a = config2 == null ? void 0 : config2.output) == null ? void 0 : _a.library;
+        if (typeof library3 === "object" && "type" in library3) {
+          isLibraryUmd = library3.type === "umd";
+        } else {
+          isLibraryUmd = ((_b = config2 == null ? void 0 : config2.output) == null ? void 0 : _b.libraryTarget) === "umd";
+        }
+        if (isLibraryUmd) {
+          return (config2 == null ? void 0 : config2.externalsType) === void 0 || (config2 == null ? void 0 : config2.externalsType) === "umd";
+        }
+        return false;
+      },
+      type: import_zod2.z.strictObject({
+        root: import_zod2.z.string().or(import_zod2.z.string().array()),
+        commonjs: import_zod2.z.string().or(import_zod2.z.string().array()),
+        commonjs2: import_zod2.z.string().or(import_zod2.z.string().array()),
+        amd: import_zod2.z.string().or(import_zod2.z.string().array())
+      }),
+      issue: (res) => {
+        if (res.status === "aborted") {
+          return [
+            {
+              fatal: true,
+              code: import_zod2.ZodIssueCode.custom,
+              message: `External object must have "root", "commonjs", "commonjs2", "amd" properties when "libraryType" or "externalsType" is "umd"`
+            }
+          ];
+        }
+        return [];
+      }
+    }
+  ],
+  default: import_zod2.z.record(import_zod2.z.string().or(import_zod2.z.string().array()))
+});
+var externalItemValue = import_zod2.z.string().or(import_zod2.z.boolean()).or(import_zod2.z.string().array().min(1)).or(ZodExternalObjectValue);
+var externalItemObjectUnknown = import_zod2.z.record(
   externalItemValue
 );
-var externalItemFunctionData = import_zod.z.strictObject({
-  context: import_zod.z.string().optional(),
-  dependencyType: import_zod.z.string().optional(),
-  request: import_zod.z.string().optional(),
-  contextInfo: import_zod.z.strictObject({
-    issuer: import_zod.z.string()
+var externalItemFunctionData = import_zod2.z.strictObject({
+  context: import_zod2.z.string().optional(),
+  dependencyType: import_zod2.z.string().optional(),
+  request: import_zod2.z.string().optional(),
+  contextInfo: import_zod2.z.strictObject({
+    issuer: import_zod2.z.string()
   }).optional()
 });
-var externalItem = import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(externalItemObjectUnknown).or(
-  import_zod.z.function().args(
+var externalItem = import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(externalItemObjectUnknown).or(
+  import_zod2.z.function().args(
     externalItemFunctionData,
-    import_zod.z.function().args(
-      import_zod.z.instanceof(Error).optional(),
+    import_zod2.z.function().args(
+      import_zod2.z.instanceof(Error).optional(),
       externalItemValue.optional(),
       externalsType.optional()
-    ).returns(import_zod.z.void())
+    ).returns(import_zod2.z.void())
   )
 ).or(
-  import_zod.z.function().args(externalItemFunctionData).returns(import_zod.z.promise(externalItemValue))
+  import_zod2.z.function().args(externalItemFunctionData).returns(import_zod2.z.promise(externalItemValue))
 );
 var externals = externalItem.array().or(externalItem);
-var externalsPresets = import_zod.z.strictObject({
-  node: import_zod.z.boolean().optional(),
-  web: import_zod.z.boolean().optional(),
-  webAsync: import_zod.z.boolean().optional(),
-  electron: import_zod.z.boolean().optional(),
-  electronMain: import_zod.z.boolean().optional(),
-  electronPreload: import_zod.z.boolean().optional(),
-  electronRenderer: import_zod.z.boolean().optional(),
-  nwjs: import_zod.z.boolean().optional()
+var externalsPresets = import_zod2.z.strictObject({
+  node: import_zod2.z.boolean().optional(),
+  web: import_zod2.z.boolean().optional(),
+  webAsync: import_zod2.z.boolean().optional(),
+  electron: import_zod2.z.boolean().optional(),
+  electronMain: import_zod2.z.boolean().optional(),
+  electronPreload: import_zod2.z.boolean().optional(),
+  electronRenderer: import_zod2.z.boolean().optional(),
+  nwjs: import_zod2.z.boolean().optional()
 });
-var filterItemTypes = import_zod.z.instanceof(RegExp).or(import_zod.z.string()).or(
-  import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean())
+var filterItemTypes = import_zod2.z.instanceof(RegExp).or(import_zod2.z.string()).or(
+  import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean())
 );
 var filterTypes = filterItemTypes.array().or(filterItemTypes);
-var infrastructureLogging = import_zod.z.strictObject({
-  appendOnly: import_zod.z.boolean().optional(),
-  colors: import_zod.z.boolean().optional(),
-  console: import_zod.z.custom().optional(),
-  debug: import_zod.z.boolean().or(filterTypes).optional(),
-  level: import_zod.z.enum(["none", "error", "warn", "info", "log", "verbose"]).optional(),
-  stream: import_zod.z.custom().optional()
+var infrastructureLogging = import_zod2.z.strictObject({
+  appendOnly: import_zod2.z.boolean().optional(),
+  colors: import_zod2.z.boolean().optional(),
+  console: import_zod2.z.custom().optional(),
+  debug: import_zod2.z.boolean().or(filterTypes).optional(),
+  level: import_zod2.z.enum(["none", "error", "warn", "info", "log", "verbose"]).optional(),
+  stream: import_zod2.z.custom().optional()
 });
-var devTool = import_zod.z.literal(false).or(
-  import_zod.z.enum([
+var devTool = import_zod2.z.literal(false).or(
+  import_zod2.z.enum([
     "eval",
     "cheap-source-map",
     "cheap-module-source-map",
@@ -10239,18 +10453,18 @@ var devTool = import_zod.z.literal(false).or(
     "eval-nosources-source-map"
   ])
 );
-var nodeOptions = import_zod.z.strictObject({
-  __dirname: import_zod.z.boolean().or(import_zod.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
-  __filename: import_zod.z.boolean().or(import_zod.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
-  global: import_zod.z.boolean().or(import_zod.z.literal("warn")).optional()
+var nodeOptions = import_zod2.z.strictObject({
+  __dirname: import_zod2.z.boolean().or(import_zod2.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
+  __filename: import_zod2.z.boolean().or(import_zod2.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
+  global: import_zod2.z.boolean().or(import_zod2.z.literal("warn")).optional()
 });
-var node = import_zod.z.literal(false).or(nodeOptions);
-var loader = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
-var snapshotOptions = import_zod.z.strictObject(
+var node = import_zod2.z.literal(false).or(nodeOptions);
+var loader = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any());
+var snapshotOptions = import_zod2.z.strictObject(
   {}
 );
-var cacheOptions = import_zod.z.boolean();
-var statsPresets = import_zod.z.enum([
+var cacheOptions = import_zod2.z.boolean();
+var statsPresets = import_zod2.z.enum([
   "normal",
   "none",
   "verbose",
@@ -10260,244 +10474,264 @@ var statsPresets = import_zod.z.enum([
   "detailed",
   "summary"
 ]);
-var statsOptions = import_zod.z.strictObject({
-  all: import_zod.z.boolean().optional(),
-  preset: import_zod.z.boolean().or(statsPresets).optional(),
-  assets: import_zod.z.boolean().optional(),
-  chunks: import_zod.z.boolean().optional(),
-  modules: import_zod.z.boolean().optional(),
-  entrypoints: import_zod.z.boolean().or(import_zod.z.literal("auto")).optional(),
-  chunkGroups: import_zod.z.boolean().optional(),
-  warnings: import_zod.z.boolean().optional(),
-  warningsCount: import_zod.z.boolean().optional(),
-  errors: import_zod.z.boolean().optional(),
-  errorsCount: import_zod.z.boolean().optional(),
-  colors: import_zod.z.boolean().optional(),
-  hash: import_zod.z.boolean().optional(),
-  version: import_zod.z.boolean().optional(),
-  reasons: import_zod.z.boolean().optional(),
-  publicPath: import_zod.z.boolean().optional(),
-  outputPath: import_zod.z.boolean().optional(),
-  chunkModules: import_zod.z.boolean().optional(),
-  chunkRelations: import_zod.z.boolean().optional(),
-  ids: import_zod.z.boolean().optional(),
-  timings: import_zod.z.boolean().optional(),
-  builtAt: import_zod.z.boolean().optional(),
-  moduleAssets: import_zod.z.boolean().optional(),
-  nestedModules: import_zod.z.boolean().optional(),
-  source: import_zod.z.boolean().optional(),
-  logging: import_zod.z.enum(["none", "error", "warn", "info", "log", "verbose"]).or(import_zod.z.boolean()).optional(),
-  loggingDebug: import_zod.z.boolean().or(filterTypes).optional(),
-  loggingTrace: import_zod.z.boolean().optional(),
-  runtimeModules: import_zod.z.boolean().optional(),
-  children: import_zod.z.boolean().optional(),
-  usedExports: import_zod.z.boolean().optional(),
-  providedExports: import_zod.z.boolean().optional(),
-  optimizationBailout: import_zod.z.boolean().optional(),
-  groupModulesByType: import_zod.z.boolean().optional(),
-  groupModulesByCacheStatus: import_zod.z.boolean().optional(),
-  groupModulesByLayer: import_zod.z.boolean().optional(),
-  groupModulesByAttributes: import_zod.z.boolean().optional(),
-  groupModulesByPath: import_zod.z.boolean().optional(),
-  groupModulesByExtension: import_zod.z.boolean().optional(),
-  modulesSpace: import_zod.z.number().optional(),
-  chunkModulesSpace: import_zod.z.number().optional(),
-  nestedModulesSpace: import_zod.z.number().optional(),
-  relatedAssets: import_zod.z.boolean().optional(),
-  groupAssetsByEmitStatus: import_zod.z.boolean().optional(),
-  groupAssetsByInfo: import_zod.z.boolean().optional(),
-  groupAssetsByPath: import_zod.z.boolean().optional(),
-  groupAssetsByExtension: import_zod.z.boolean().optional(),
-  groupAssetsByChunk: import_zod.z.boolean().optional(),
-  assetsSpace: import_zod.z.number().optional(),
-  orphanModules: import_zod.z.boolean().optional(),
-  excludeModules: import_zod.z.array(
-    import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any(), import_zod.z.any()]), import_zod.z.boolean()))
-  ).or(import_zod.z.string()).or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any(), import_zod.z.any()]), import_zod.z.boolean())).or(import_zod.z.boolean()).optional(),
-  excludeAssets: import_zod.z.array(
-    import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any()]), import_zod.z.boolean()))
-  ).or(import_zod.z.string()).or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any()]), import_zod.z.boolean())).optional(),
-  modulesSort: import_zod.z.string().optional(),
-  chunkModulesSort: import_zod.z.string().optional(),
-  nestedModulesSort: import_zod.z.string().optional(),
-  chunksSort: import_zod.z.string().optional(),
-  assetsSort: import_zod.z.string().optional(),
-  performance: import_zod.z.boolean().optional(),
-  env: import_zod.z.boolean().optional(),
-  chunkGroupAuxiliary: import_zod.z.boolean().optional(),
-  chunkGroupChildren: import_zod.z.boolean().optional(),
-  chunkGroupMaxAssets: import_zod.z.number().optional(),
-  dependentModules: import_zod.z.boolean().optional(),
-  chunkOrigins: import_zod.z.boolean().optional(),
-  runtime: import_zod.z.boolean().optional(),
-  depth: import_zod.z.boolean().optional(),
-  reasonsSpace: import_zod.z.number().optional(),
-  groupReasonsByOrigin: import_zod.z.boolean().optional(),
-  errorDetails: import_zod.z.boolean().optional(),
-  errorStack: import_zod.z.boolean().optional(),
-  moduleTrace: import_zod.z.boolean().optional(),
-  cachedModules: import_zod.z.boolean().optional(),
-  cachedAssets: import_zod.z.boolean().optional(),
-  cached: import_zod.z.boolean().optional(),
-  errorsSpace: import_zod.z.number().optional(),
-  warningsSpace: import_zod.z.number().optional()
+var statsOptions = import_zod2.z.strictObject({
+  all: import_zod2.z.boolean().optional(),
+  preset: import_zod2.z.boolean().or(statsPresets).optional(),
+  assets: import_zod2.z.boolean().optional(),
+  chunks: import_zod2.z.boolean().optional(),
+  modules: import_zod2.z.boolean().optional(),
+  entrypoints: import_zod2.z.boolean().or(import_zod2.z.literal("auto")).optional(),
+  chunkGroups: import_zod2.z.boolean().optional(),
+  warnings: import_zod2.z.boolean().optional(),
+  warningsCount: import_zod2.z.boolean().optional(),
+  errors: import_zod2.z.boolean().optional(),
+  errorsCount: import_zod2.z.boolean().optional(),
+  colors: import_zod2.z.boolean().optional(),
+  hash: import_zod2.z.boolean().optional(),
+  version: import_zod2.z.boolean().optional(),
+  reasons: import_zod2.z.boolean().optional(),
+  publicPath: import_zod2.z.boolean().optional(),
+  outputPath: import_zod2.z.boolean().optional(),
+  chunkModules: import_zod2.z.boolean().optional(),
+  chunkRelations: import_zod2.z.boolean().optional(),
+  ids: import_zod2.z.boolean().optional(),
+  timings: import_zod2.z.boolean().optional(),
+  builtAt: import_zod2.z.boolean().optional(),
+  moduleAssets: import_zod2.z.boolean().optional(),
+  nestedModules: import_zod2.z.boolean().optional(),
+  source: import_zod2.z.boolean().optional(),
+  logging: import_zod2.z.enum(["none", "error", "warn", "info", "log", "verbose"]).or(import_zod2.z.boolean()).optional(),
+  loggingDebug: import_zod2.z.boolean().or(filterTypes).optional(),
+  loggingTrace: import_zod2.z.boolean().optional(),
+  runtimeModules: import_zod2.z.boolean().optional(),
+  children: import_zod2.z.boolean().optional(),
+  usedExports: import_zod2.z.boolean().optional(),
+  providedExports: import_zod2.z.boolean().optional(),
+  optimizationBailout: import_zod2.z.boolean().optional(),
+  groupModulesByType: import_zod2.z.boolean().optional(),
+  groupModulesByCacheStatus: import_zod2.z.boolean().optional(),
+  groupModulesByLayer: import_zod2.z.boolean().optional(),
+  groupModulesByAttributes: import_zod2.z.boolean().optional(),
+  groupModulesByPath: import_zod2.z.boolean().optional(),
+  groupModulesByExtension: import_zod2.z.boolean().optional(),
+  modulesSpace: import_zod2.z.number().optional(),
+  chunkModulesSpace: import_zod2.z.number().optional(),
+  nestedModulesSpace: import_zod2.z.number().optional(),
+  relatedAssets: import_zod2.z.boolean().optional(),
+  groupAssetsByEmitStatus: import_zod2.z.boolean().optional(),
+  groupAssetsByInfo: import_zod2.z.boolean().optional(),
+  groupAssetsByPath: import_zod2.z.boolean().optional(),
+  groupAssetsByExtension: import_zod2.z.boolean().optional(),
+  groupAssetsByChunk: import_zod2.z.boolean().optional(),
+  assetsSpace: import_zod2.z.number().optional(),
+  orphanModules: import_zod2.z.boolean().optional(),
+  excludeModules: import_zod2.z.array(
+    import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any(), import_zod2.z.any()]), import_zod2.z.boolean()))
+  ).or(import_zod2.z.string()).or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any(), import_zod2.z.any()]), import_zod2.z.boolean())).or(import_zod2.z.boolean()).optional(),
+  excludeAssets: import_zod2.z.array(
+    import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any()]), import_zod2.z.boolean()))
+  ).or(import_zod2.z.string()).or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any()]), import_zod2.z.boolean())).optional(),
+  modulesSort: import_zod2.z.string().optional(),
+  chunkModulesSort: import_zod2.z.string().optional(),
+  nestedModulesSort: import_zod2.z.string().optional(),
+  chunksSort: import_zod2.z.string().optional(),
+  assetsSort: import_zod2.z.string().optional(),
+  performance: import_zod2.z.boolean().optional(),
+  env: import_zod2.z.boolean().optional(),
+  chunkGroupAuxiliary: import_zod2.z.boolean().optional(),
+  chunkGroupChildren: import_zod2.z.boolean().optional(),
+  chunkGroupMaxAssets: import_zod2.z.number().optional(),
+  dependentModules: import_zod2.z.boolean().optional(),
+  chunkOrigins: import_zod2.z.boolean().optional(),
+  runtime: import_zod2.z.boolean().optional(),
+  depth: import_zod2.z.boolean().optional(),
+  reasonsSpace: import_zod2.z.number().optional(),
+  groupReasonsByOrigin: import_zod2.z.boolean().optional(),
+  errorDetails: import_zod2.z.boolean().optional(),
+  errorStack: import_zod2.z.boolean().optional(),
+  moduleTrace: import_zod2.z.boolean().optional(),
+  cachedModules: import_zod2.z.boolean().optional(),
+  cachedAssets: import_zod2.z.boolean().optional(),
+  cached: import_zod2.z.boolean().optional(),
+  errorsSpace: import_zod2.z.number().optional(),
+  warningsSpace: import_zod2.z.number().optional()
 });
-var statsValue = import_zod.z.boolean().or(statsPresets).or(statsOptions);
-var plugin = import_zod.z.union([
-  import_zod.z.custom(),
+var statsValue = import_zod2.z.boolean().or(statsPresets).or(statsOptions);
+var plugin = import_zod2.z.union([
+  import_zod2.z.custom(),
   falsy
 ]);
 var plugins = plugin.array();
-var optimizationRuntimeChunk = import_zod.z.enum(["single", "multiple"]).or(import_zod.z.boolean()).or(
-  import_zod.z.strictObject({
-    name: import_zod.z.string().or(
-      import_zod.z.function().args(import_zod.z.strictObject({ name: import_zod.z.string() })).returns(import_zod.z.string())
+var optimizationRuntimeChunk = import_zod2.z.enum(["single", "multiple"]).or(import_zod2.z.boolean()).or(
+  import_zod2.z.strictObject({
+    name: import_zod2.z.string().or(
+      import_zod2.z.function().args(import_zod2.z.strictObject({ name: import_zod2.z.string() })).returns(import_zod2.z.string())
     ).optional()
   })
 );
-var optimizationSplitChunksNameFunction = import_zod.z.function().args(
-  import_zod.z.instanceof(Module).optional()
+var optimizationSplitChunksNameFunction = import_zod2.z.function().args(
+  import_zod2.z.instanceof(Module).optional()
   // FIXME: z.array(z.instanceof(Chunk)).optional(), z.string()
   // FIXME: Chunk[],   															cacheChunkKey
 );
-var optimizationSplitChunksName = import_zod.z.string().or(import_zod.z.literal(false)).or(optimizationSplitChunksNameFunction);
-var optimizationSplitChunksChunks = import_zod.z.enum(["initial", "async", "all"]).or(import_zod.z.instanceof(RegExp)).or(
-  import_zod.z.function().args(import_zod.z.instanceof(Chunk, { message: "Input not instance of Chunk" })).returns(import_zod.z.boolean())
+var optimizationSplitChunksName = import_zod2.z.string().or(import_zod2.z.literal(false)).or(optimizationSplitChunksNameFunction);
+var optimizationSplitChunksChunks = import_zod2.z.enum(["initial", "async", "all"]).or(import_zod2.z.instanceof(RegExp)).or(
+  import_zod2.z.function().args(import_zod2.z.instanceof(Chunk, { message: "Input not instance of Chunk" })).returns(import_zod2.z.boolean())
 );
-var optimizationSplitChunksSizes = import_zod.z.number().or(import_zod.z.record(import_zod.z.number()));
-var optimizationSplitChunksDefaultSizeTypes = import_zod.z.array(import_zod.z.string());
+var optimizationSplitChunksSizes = import_zod2.z.number().or(import_zod2.z.record(import_zod2.z.number()));
+var optimizationSplitChunksDefaultSizeTypes = import_zod2.z.array(import_zod2.z.string());
 var sharedOptimizationSplitChunksCacheGroup = {
   chunks: optimizationSplitChunksChunks.optional(),
   defaultSizeTypes: optimizationSplitChunksDefaultSizeTypes.optional(),
-  minChunks: import_zod.z.number().min(1).optional(),
-  usedExports: import_zod.z.boolean().optional(),
+  minChunks: import_zod2.z.number().min(1).optional(),
+  usedExports: import_zod2.z.boolean().optional(),
   name: optimizationSplitChunksName.optional(),
   minSize: optimizationSplitChunksSizes.optional(),
   maxSize: optimizationSplitChunksSizes.optional(),
   maxAsyncSize: optimizationSplitChunksSizes.optional(),
   maxInitialSize: optimizationSplitChunksSizes.optional(),
-  maxAsyncRequests: import_zod.z.number().optional(),
-  maxInitialRequests: import_zod.z.number().optional(),
-  automaticNameDelimiter: import_zod.z.string().optional()
-};
-var optimizationSplitChunksCacheGroup = import_zod.z.strictObject({
-  test: import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(
-    import_zod.z.function().args(
-      import_zod.z.instanceof(Module)
+  maxAsyncRequests: import_zod2.z.number().optional(),
+  maxInitialRequests: import_zod2.z.number().optional(),
+  automaticNameDelimiter: import_zod2.z.string().optional()
+};
+var optimizationSplitChunksCacheGroup = import_zod2.z.strictObject({
+  test: import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(
+    import_zod2.z.function().args(
+      import_zod2.z.instanceof(Module)
       /** FIXME: lack of CacheGroupContext */
     )
   ).optional(),
-  priority: import_zod.z.number().optional(),
-  enforce: import_zod.z.boolean().optional(),
-  filename: import_zod.z.string().optional(),
-  reuseExistingChunk: import_zod.z.boolean().optional(),
-  type: import_zod.z.string().or(import_zod.z.instanceof(RegExp)).optional(),
-  idHint: import_zod.z.string().optional(),
+  priority: import_zod2.z.number().optional(),
+  enforce: import_zod2.z.boolean().optional(),
+  filename: import_zod2.z.string().optional(),
+  reuseExistingChunk: import_zod2.z.boolean().optional(),
+  type: import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).optional(),
+  idHint: import_zod2.z.string().optional(),
   ...sharedOptimizationSplitChunksCacheGroup
 });
-var optimizationSplitChunksOptions = import_zod.z.strictObject({
-  cacheGroups: import_zod.z.record(import_zod.z.literal(false).or(optimizationSplitChunksCacheGroup)).optional(),
-  fallbackCacheGroup: import_zod.z.strictObject({
+var optimizationSplitChunksOptions = import_zod2.z.strictObject({
+  cacheGroups: import_zod2.z.record(import_zod2.z.literal(false).or(optimizationSplitChunksCacheGroup)).optional(),
+  fallbackCacheGroup: import_zod2.z.strictObject({
     chunks: optimizationSplitChunksChunks.optional(),
-    minSize: import_zod.z.number().optional(),
-    maxSize: import_zod.z.number().optional(),
-    maxAsyncSize: import_zod.z.number().optional(),
-    maxInitialSize: import_zod.z.number().optional(),
-    automaticNameDelimiter: import_zod.z.string().optional()
+    minSize: import_zod2.z.number().optional(),
+    maxSize: import_zod2.z.number().optional(),
+    maxAsyncSize: import_zod2.z.number().optional(),
+    maxInitialSize: import_zod2.z.number().optional(),
+    automaticNameDelimiter: import_zod2.z.string().optional()
   }).optional(),
-  hidePathInfo: import_zod.z.boolean().optional(),
+  hidePathInfo: import_zod2.z.boolean().optional(),
   ...sharedOptimizationSplitChunksCacheGroup
 });
-var optimization = import_zod.z.strictObject({
-  moduleIds: import_zod.z.enum(["named", "natural", "deterministic"]).optional(),
-  chunkIds: import_zod.z.enum(["natural", "named", "deterministic"]).optional(),
-  minimize: import_zod.z.boolean().optional(),
-  minimizer: import_zod.z.literal("...").or(plugin).array().optional(),
-  mergeDuplicateChunks: import_zod.z.boolean().optional(),
-  splitChunks: import_zod.z.literal(false).or(optimizationSplitChunksOptions).optional(),
+var optimization = import_zod2.z.strictObject({
+  moduleIds: import_zod2.z.enum(["named", "natural", "deterministic"]).optional(),
+  chunkIds: import_zod2.z.enum(["natural", "named", "deterministic"]).optional(),
+  minimize: import_zod2.z.boolean().optional(),
+  minimizer: import_zod2.z.literal("...").or(plugin).array().optional(),
+  mergeDuplicateChunks: import_zod2.z.boolean().optional(),
+  splitChunks: import_zod2.z.literal(false).or(optimizationSplitChunksOptions).optional(),
   runtimeChunk: optimizationRuntimeChunk.optional(),
-  removeAvailableModules: import_zod.z.boolean().optional(),
-  removeEmptyChunks: import_zod.z.boolean().optional(),
-  realContentHash: import_zod.z.boolean().optional(),
-  sideEffects: import_zod.z.enum(["flag"]).or(import_zod.z.boolean()).optional(),
-  providedExports: import_zod.z.boolean().optional(),
-  concatenateModules: import_zod.z.boolean().optional(),
-  innerGraph: import_zod.z.boolean().optional(),
-  usedExports: import_zod.z.enum(["global"]).or(import_zod.z.boolean()).optional(),
-  mangleExports: import_zod.z.enum(["size", "deterministic"]).or(import_zod.z.boolean()).optional(),
-  nodeEnv: import_zod.z.union([import_zod.z.string(), import_zod.z.literal(false)]).optional(),
-  emitOnErrors: import_zod.z.boolean().optional()
+  removeAvailableModules: import_zod2.z.boolean().optional(),
+  removeEmptyChunks: import_zod2.z.boolean().optional(),
+  realContentHash: import_zod2.z.boolean().optional(),
+  sideEffects: import_zod2.z.enum(["flag"]).or(import_zod2.z.boolean()).optional(),
+  providedExports: import_zod2.z.boolean().optional(),
+  concatenateModules: import_zod2.z.boolean().optional(),
+  innerGraph: import_zod2.z.boolean().optional(),
+  usedExports: import_zod2.z.enum(["global"]).or(import_zod2.z.boolean()).optional(),
+  mangleExports: import_zod2.z.enum(["size", "deterministic"]).or(import_zod2.z.boolean()).optional(),
+  nodeEnv: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.literal(false)]).optional(),
+  emitOnErrors: import_zod2.z.boolean().optional()
 });
-var rspackFutureOptions = import_zod.z.strictObject({
-  bundlerInfo: import_zod.z.strictObject({
-    version: import_zod.z.string().optional(),
-    bundler: import_zod.z.string().optional(),
-    force: import_zod.z.boolean().or(import_zod.z.array(import_zod.z.enum(["version", "uniqueId"]))).optional()
+var rspackFutureOptions = import_zod2.z.strictObject({
+  bundlerInfo: import_zod2.z.strictObject({
+    version: import_zod2.z.string().optional(),
+    bundler: import_zod2.z.string().optional(),
+    force: import_zod2.z.boolean().or(import_zod2.z.array(import_zod2.z.enum(["version", "uniqueId"]))).optional()
   }).optional()
 });
-var listenOptions = import_zod.z.object({
-  port: import_zod.z.number().optional(),
-  host: import_zod.z.string().optional(),
-  backlog: import_zod.z.number().optional(),
-  path: import_zod.z.string().optional(),
-  exclusive: import_zod.z.boolean().optional(),
-  readableAll: import_zod.z.boolean().optional(),
-  writableAll: import_zod.z.boolean().optional(),
-  ipv6Only: import_zod.z.boolean().optional()
+var listenOptions = import_zod2.z.object({
+  port: import_zod2.z.number().optional(),
+  host: import_zod2.z.string().optional(),
+  backlog: import_zod2.z.number().optional(),
+  path: import_zod2.z.string().optional(),
+  exclusive: import_zod2.z.boolean().optional(),
+  readableAll: import_zod2.z.boolean().optional(),
+  writableAll: import_zod2.z.boolean().optional(),
+  ipv6Only: import_zod2.z.boolean().optional()
 });
-var lazyCompilationOptions = import_zod.z.object({
-  backend: import_zod.z.object({
-    client: import_zod.z.string().optional(),
-    listen: import_zod.z.number().optional().or(listenOptions),
-    protocol: import_zod.z.enum(["http", "https"]).optional()
+var experimentCacheOptions = import_zod2.z.object({
+  type: import_zod2.z.enum(["memory"])
+}).or(
+  import_zod2.z.object({
+    type: import_zod2.z.enum(["persistent"]),
+    snapshot: import_zod2.z.strictObject({
+      immutablePaths: import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).array(),
+      unmanagedPaths: import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).array(),
+      managedPaths: import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).array()
+    }),
+    storage: import_zod2.z.strictObject({
+      type: import_zod2.z.enum(["filesystem"]),
+      directory: import_zod2.z.string()
+    })
+  })
+);
+var lazyCompilationOptions = import_zod2.z.object({
+  backend: import_zod2.z.object({
+    client: import_zod2.z.string().optional(),
+    listen: import_zod2.z.number().optional().or(listenOptions),
+    protocol: import_zod2.z.enum(["http", "https"]).optional()
   }).optional(),
-  imports: import_zod.z.boolean().optional(),
-  entries: import_zod.z.boolean().optional(),
-  test: import_zod.z.instanceof(RegExp).or(import_zod.z.function().args(import_zod.z.custom()).returns(import_zod.z.boolean())).optional()
+  imports: import_zod2.z.boolean().optional(),
+  entries: import_zod2.z.boolean().optional(),
+  test: import_zod2.z.instanceof(RegExp).or(import_zod2.z.function().args(import_zod2.z.custom()).returns(import_zod2.z.boolean())).optional()
 });
-var incremental = import_zod.z.strictObject({
-  make: import_zod.z.boolean().optional(),
-  emitAssets: import_zod.z.boolean().optional(),
-  inferAsyncModules: import_zod.z.boolean().optional(),
-  providedExports: import_zod.z.boolean().optional(),
-  dependenciesDiagnostics: import_zod.z.boolean().optional(),
-  modulesHashes: import_zod.z.boolean().optional(),
-  modulesCodegen: import_zod.z.boolean().optional(),
-  modulesRuntimeRequirements: import_zod.z.boolean().optional(),
-  buildChunkGraph: import_zod.z.boolean().optional()
+var incremental = import_zod2.z.strictObject({
+  make: import_zod2.z.boolean().optional(),
+  inferAsyncModules: import_zod2.z.boolean().optional(),
+  providedExports: import_zod2.z.boolean().optional(),
+  dependenciesDiagnostics: import_zod2.z.boolean().optional(),
+  buildChunkGraph: import_zod2.z.boolean().optional(),
+  modulesHashes: import_zod2.z.boolean().optional(),
+  modulesCodegen: import_zod2.z.boolean().optional(),
+  modulesRuntimeRequirements: import_zod2.z.boolean().optional(),
+  chunksRuntimeRequirements: import_zod2.z.boolean().optional(),
+  chunksHashes: import_zod2.z.boolean().optional(),
+  chunksRender: import_zod2.z.boolean().optional(),
+  emitAssets: import_zod2.z.boolean().optional()
 });
-var experiments = import_zod.z.strictObject({
-  lazyCompilation: import_zod.z.boolean().optional().or(lazyCompilationOptions),
-  asyncWebAssembly: import_zod.z.boolean().optional(),
-  outputModule: import_zod.z.boolean().optional(),
-  topLevelAwait: import_zod.z.boolean().optional(),
-  css: import_zod.z.boolean().optional(),
-  layers: import_zod.z.boolean().optional(),
-  incremental: import_zod.z.boolean().or(incremental).optional(),
-  futureDefaults: import_zod.z.boolean().optional(),
+var experiments = import_zod2.z.strictObject({
+  cache: import_zod2.z.boolean().optional().or(experimentCacheOptions),
+  lazyCompilation: import_zod2.z.boolean().optional().or(lazyCompilationOptions),
+  asyncWebAssembly: import_zod2.z.boolean().optional(),
+  outputModule: import_zod2.z.boolean().optional(),
+  topLevelAwait: import_zod2.z.boolean().optional(),
+  css: import_zod2.z.boolean().optional(),
+  layers: import_zod2.z.boolean().optional(),
+  incremental: import_zod2.z.boolean().or(incremental).optional(),
+  futureDefaults: import_zod2.z.boolean().optional(),
   rspackFuture: rspackFutureOptions.optional()
 });
-var watch = import_zod.z.boolean();
-var watchOptions = import_zod.z.strictObject({
-  aggregateTimeout: import_zod.z.number().optional(),
-  followSymlinks: import_zod.z.boolean().optional(),
-  ignored: import_zod.z.string().array().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.string()).optional(),
-  poll: import_zod.z.number().or(import_zod.z.boolean()).optional(),
-  stdin: import_zod.z.boolean().optional()
+var watch = import_zod2.z.boolean();
+var watchOptions = import_zod2.z.strictObject({
+  aggregateTimeout: import_zod2.z.number().optional(),
+  followSymlinks: import_zod2.z.boolean().optional(),
+  ignored: import_zod2.z.string().array().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.string()).optional(),
+  poll: import_zod2.z.number().or(import_zod2.z.boolean()).optional(),
+  stdin: import_zod2.z.boolean().optional()
 });
-var devServer = import_zod.z.custom();
-var ignoreWarnings = import_zod.z.instanceof(RegExp).or(
-  import_zod.z.function().args(import_zod.z.instanceof(Error), import_zod.z.custom()).returns(import_zod.z.boolean())
+var devServer = import_zod2.z.custom();
+var ignoreWarnings = import_zod2.z.instanceof(RegExp).or(
+  import_zod2.z.function().args(import_zod2.z.instanceof(Error), import_zod2.z.custom()).returns(import_zod2.z.boolean())
 ).array();
-var profile = import_zod.z.boolean();
-var bail = import_zod.z.boolean();
-var performance = import_zod.z.strictObject({
-  assetFilter: import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()).optional(),
-  hints: import_zod.z.enum(["error", "warning"]).or(import_zod.z.literal(false)).optional(),
-  maxAssetSize: import_zod.z.number().optional(),
-  maxEntrypointSize: import_zod.z.number().optional()
-}).or(import_zod.z.literal(false));
-var rspackOptions = import_zod.z.strictObject({
+var profile = import_zod2.z.boolean();
+var bail = import_zod2.z.boolean();
+var performance = import_zod2.z.strictObject({
+  assetFilter: import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean()).optional(),
+  hints: import_zod2.z.enum(["error", "warning"]).or(import_zod2.z.literal(false)).optional(),
+  maxAssetSize: import_zod2.z.number().optional(),
+  maxEntrypointSize: import_zod2.z.number().optional()
+}).or(import_zod2.z.literal(false));
+var rspackOptions = import_zod2.z.strictObject({
   name: name.optional(),
   dependencies: dependencies.optional(),
   entry: entry.optional(),
@@ -10532,7 +10766,7 @@ var rspackOptions = import_zod.z.strictObject({
 
 // src/builtin-plugin/EntryPlugin.ts
 var EntryPlugin = create2(
-  import_binding25.BuiltinPluginName.EntryPlugin,
+  import_binding24.BuiltinPluginName.EntryPlugin,
   (context2, entry2, options = "") => {
     const entryOptions = typeof options === "string" ? { name: options } : options;
     return {
@@ -10566,7 +10800,7 @@ var DynamicEntryPlugin = class extends RspackBuiltinPlugin {
     super();
     this.context = context2;
     this.entry = entry2;
-    this.name = import_binding26.BuiltinPluginName.DynamicEntryPlugin;
+    this.name = import_binding25.BuiltinPluginName.DynamicEntryPlugin;
     this.affectedHooks = "make";
   }
   raw(compiler) {
@@ -10592,21 +10826,21 @@ var DynamicEntryPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/ElectronTargetPlugin.ts
-var import_binding27 = require("@rspack/binding");
+var import_binding26 = require("@rspack/binding");
 var ElectronTargetPlugin = create2(
-  import_binding27.BuiltinPluginName.ElectronTargetPlugin,
+  import_binding26.BuiltinPluginName.ElectronTargetPlugin,
   (context2) => context2 ?? "none"
 );
 
 // src/builtin-plugin/EnableChunkLoadingPlugin.ts
-var import_binding28 = require("@rspack/binding");
+var import_binding27 = require("@rspack/binding");
 var EnableChunkLoadingPlugin = create2(
-  import_binding28.BuiltinPluginName.EnableChunkLoadingPlugin,
+  import_binding27.BuiltinPluginName.EnableChunkLoadingPlugin,
   (type) => type
 );
 
 // src/builtin-plugin/EnableLibraryPlugin.ts
-var import_binding29 = require("@rspack/binding");
+var import_binding28 = require("@rspack/binding");
 var enabledTypes = /* @__PURE__ */ new WeakMap();
 var getEnabledTypes = (compiler) => {
   let set = enabledTypes.get(compiler);
@@ -10620,7 +10854,7 @@ var EnableLibraryPlugin = class extends RspackBuiltinPlugin {
   constructor(type) {
     super();
     this.type = type;
-    this.name = import_binding29.BuiltinPluginName.EnableLibraryPlugin;
+    this.name = import_binding28.BuiltinPluginName.EnableLibraryPlugin;
   }
   static setEnabled(compiler, type) {
     getEnabledTypes(compiler).add(type);
@@ -10642,32 +10876,32 @@ var EnableLibraryPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/EnableWasmLoadingPlugin.ts
-var import_binding30 = require("@rspack/binding");
+var import_binding29 = require("@rspack/binding");
 var EnableWasmLoadingPlugin = create2(
-  import_binding30.BuiltinPluginName.EnableWasmLoadingPlugin,
+  import_binding29.BuiltinPluginName.EnableWasmLoadingPlugin,
   (type) => type
 );
 
 // src/builtin-plugin/EnsureChunkConditionsPlugin.ts
-var import_binding31 = require("@rspack/binding");
+var import_binding30 = require("@rspack/binding");
 var EnsureChunkConditionsPlugin = create2(
-  import_binding31.BuiltinPluginName.EnsureChunkConditionsPlugin,
+  import_binding30.BuiltinPluginName.EnsureChunkConditionsPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/EvalDevToolModulePlugin.ts
-var import_binding32 = require("@rspack/binding");
+var import_binding31 = require("@rspack/binding");
 var EvalDevToolModulePlugin = create2(
-  import_binding32.BuiltinPluginName.EvalDevToolModulePlugin,
+  import_binding31.BuiltinPluginName.EvalDevToolModulePlugin,
   (options) => options,
   "compilation"
 );
 
 // src/builtin-plugin/EvalSourceMapDevToolPlugin.ts
-var import_binding33 = require("@rspack/binding");
+var import_binding32 = require("@rspack/binding");
 var EvalSourceMapDevToolPlugin = create2(
-  import_binding33.BuiltinPluginName.EvalSourceMapDevToolPlugin,
+  import_binding32.BuiltinPluginName.EvalSourceMapDevToolPlugin,
   (options) => {
     return {
       filename: options.filename || void 0,
@@ -10683,9 +10917,9 @@ var EvalSourceMapDevToolPlugin = create2(
 );
 
 // src/builtin-plugin/ExternalsPlugin.ts
-var import_binding34 = require("@rspack/binding");
+var import_binding33 = require("@rspack/binding");
 var ExternalsPlugin = create2(
-  import_binding34.BuiltinPluginName.ExternalsPlugin,
+  import_binding33.BuiltinPluginName.ExternalsPlugin,
   (type, externals2) => {
     return {
       type,
@@ -10739,30 +10973,30 @@ function getRawExternalItemValue(value) {
 }
 
 // src/builtin-plugin/FileUriPlugin.ts
-var import_binding35 = require("@rspack/binding");
+var import_binding34 = require("@rspack/binding");
 var FileUriPlugin = create2(
-  import_binding35.BuiltinPluginName.FileUriPlugin,
+  import_binding34.BuiltinPluginName.FileUriPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/FlagDependencyExportsPlugin.ts
-var import_binding36 = require("@rspack/binding");
+var import_binding35 = require("@rspack/binding");
 var FlagDependencyExportsPlugin = create2(
-  import_binding36.BuiltinPluginName.FlagDependencyExportsPlugin,
+  import_binding35.BuiltinPluginName.FlagDependencyExportsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/FlagDependencyUsagePlugin.ts
-var import_binding37 = require("@rspack/binding");
+var import_binding36 = require("@rspack/binding");
 var FlagDependencyUsagePlugin = class extends RspackBuiltinPlugin {
   constructor(global) {
     super();
     this.global = global;
-    this.name = import_binding37.BuiltinPluginName.FlagDependencyUsagePlugin;
+    this.name = import_binding36.BuiltinPluginName.FlagDependencyUsagePlugin;
     this.affectedHooks = "compilation";
   }
   raw(compiler) {
@@ -10793,11 +11027,11 @@ var FlagDependencyUsagePlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/HotModuleReplacementPlugin.ts
-var import_binding38 = require("@rspack/binding");
+var import_binding37 = require("@rspack/binding");
 var HotModuleReplacementPlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding38.BuiltinPluginName.HotModuleReplacementPlugin;
+    this.name = import_binding37.BuiltinPluginName.HotModuleReplacementPlugin;
   }
   raw(compiler) {
     if (compiler.options.output.strictModuleErrorHandling === void 0) {
@@ -10810,9 +11044,9 @@ var HotModuleReplacementPlugin = class extends RspackBuiltinPlugin {
 // src/builtin-plugin/HtmlRspackPlugin.ts
 var import_node_fs2 = __toESM(require("fs"));
 var import_node_path8 = __toESM(require("path"));
-var import_binding39 = require("@rspack/binding");
+var import_binding38 = require("@rspack/binding");
 var liteTapable3 = __toESM(require("@rspack/lite-tapable"));
-var import_zod2 = require("../compiled/zod/index.js");
+var import_zod3 = require("../compiled/zod/index.js");
 
 // ../../node_modules/.pnpm/zod-validation-error@3.4.0_zod@3.23.8/node_modules/zod-validation-error/dist/index.mjs
 var zod2 = __toESM(require("../compiled/zod/index.js"), 1);
@@ -11063,43 +11297,43 @@ function isValidate(opts, schema) {
 }
 
 // src/builtin-plugin/HtmlRspackPlugin.ts
-var templateRenderFunction = import_zod2.z.function().args(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any())).returns(
-  import_zod2.z.string().or(import_zod2.z.promise(import_zod2.z.string()))
+var templateRenderFunction = import_zod3.z.function().args(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any())).returns(
+  import_zod3.z.string().or(import_zod3.z.promise(import_zod3.z.string()))
 );
-var templateParamFunction = import_zod2.z.function().args(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any())).returns(
-  import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any()).or(import_zod2.z.promise(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any())))
+var templateParamFunction = import_zod3.z.function().args(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any())).returns(
+  import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).or(import_zod3.z.promise(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any())))
 );
-var templateFilenameFunction = import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.string());
-var htmlRspackPluginOptions = import_zod2.z.strictObject({
-  filename: import_zod2.z.string().or(templateFilenameFunction).optional(),
-  template: import_zod2.z.string().refine(
+var templateFilenameFunction = import_zod3.z.function().args(import_zod3.z.string()).returns(import_zod3.z.string());
+var htmlRspackPluginOptions = import_zod3.z.strictObject({
+  filename: import_zod3.z.string().or(templateFilenameFunction).optional(),
+  template: import_zod3.z.string().refine(
     (val) => !val.includes("!"),
     () => ({
       message: "HtmlRspackPlugin does not support template path with loader yet"
     })
   ).optional(),
-  templateContent: import_zod2.z.string().or(templateRenderFunction).optional(),
-  templateParameters: import_zod2.z.record(import_zod2.z.string()).or(import_zod2.z.boolean()).or(templateParamFunction).optional(),
-  inject: import_zod2.z.enum(["head", "body"]).or(import_zod2.z.boolean()).optional(),
-  publicPath: import_zod2.z.string().optional(),
-  base: import_zod2.z.string().or(
-    import_zod2.z.strictObject({
-      href: import_zod2.z.string().optional(),
-      target: import_zod2.z.enum(["_self", "_blank", "_parent", "_top"]).optional()
+  templateContent: import_zod3.z.string().or(templateRenderFunction).optional(),
+  templateParameters: import_zod3.z.record(import_zod3.z.string()).or(import_zod3.z.boolean()).or(templateParamFunction).optional(),
+  inject: import_zod3.z.enum(["head", "body"]).or(import_zod3.z.boolean()).optional(),
+  publicPath: import_zod3.z.string().optional(),
+  base: import_zod3.z.string().or(
+    import_zod3.z.strictObject({
+      href: import_zod3.z.string().optional(),
+      target: import_zod3.z.enum(["_self", "_blank", "_parent", "_top"]).optional()
     })
   ).optional(),
-  scriptLoading: import_zod2.z.enum(["blocking", "defer", "module", "systemjs-module"]).optional(),
-  chunks: import_zod2.z.string().array().optional(),
-  excludeChunks: import_zod2.z.string().array().optional(),
-  sri: import_zod2.z.enum(["sha256", "sha384", "sha512"]).optional(),
-  minify: import_zod2.z.boolean().optional(),
-  title: import_zod2.z.string().optional(),
-  favicon: import_zod2.z.string().optional(),
-  meta: import_zod2.z.record(import_zod2.z.string().or(import_zod2.z.record(import_zod2.z.string()))).optional(),
-  hash: import_zod2.z.boolean().optional()
+  scriptLoading: import_zod3.z.enum(["blocking", "defer", "module", "systemjs-module"]).optional(),
+  chunks: import_zod3.z.string().array().optional(),
+  excludeChunks: import_zod3.z.string().array().optional(),
+  sri: import_zod3.z.enum(["sha256", "sha384", "sha512"]).optional(),
+  minify: import_zod3.z.boolean().optional(),
+  title: import_zod3.z.string().optional(),
+  favicon: import_zod3.z.string().optional(),
+  meta: import_zod3.z.record(import_zod3.z.string().or(import_zod3.z.record(import_zod3.z.string()))).optional(),
+  hash: import_zod3.z.boolean().optional()
 });
 var HtmlRspackPluginImpl = create2(
-  import_binding39.BuiltinPluginName.HtmlRspackPlugin,
+  import_binding38.BuiltinPluginName.HtmlRspackPlugin,
   function(c = {}) {
     validate(c, htmlRspackPluginOptions);
     const meta = {};
@@ -11336,9 +11570,9 @@ HtmlRspackPlugin.getHooks = HtmlRspackPlugin.getCompilationHooks = (compilation)
 HtmlRspackPlugin.version = 5;
 
 // src/builtin-plugin/HttpExternalsRspackPlugin.ts
-var import_binding40 = require("@rspack/binding");
+var import_binding39 = require("@rspack/binding");
 var HttpExternalsRspackPlugin = create2(
-  import_binding40.BuiltinPluginName.HttpExternalsRspackPlugin,
+  import_binding39.BuiltinPluginName.HttpExternalsRspackPlugin,
   (css, webAsync) => {
     return {
       css,
@@ -11348,19 +11582,19 @@ var HttpExternalsRspackPlugin = create2(
 );
 
 // src/builtin-plugin/IgnorePlugin.ts
-var import_binding41 = require("@rspack/binding");
-var import_zod3 = require("../compiled/zod/index.js");
-var IgnorePluginOptions = import_zod3.z.union([
-  import_zod3.z.object({
-    contextRegExp: import_zod3.z.instanceof(RegExp).optional(),
-    resourceRegExp: import_zod3.z.instanceof(RegExp)
+var import_binding40 = require("@rspack/binding");
+var import_zod4 = require("../compiled/zod/index.js");
+var IgnorePluginOptions = import_zod4.z.union([
+  import_zod4.z.object({
+    contextRegExp: import_zod4.z.instanceof(RegExp).optional(),
+    resourceRegExp: import_zod4.z.instanceof(RegExp)
   }),
-  import_zod3.z.object({
-    checkResource: import_zod3.z.function(import_zod3.z.tuple([import_zod3.z.string(), import_zod3.z.string()]), import_zod3.z.boolean())
+  import_zod4.z.object({
+    checkResource: import_zod4.z.function(import_zod4.z.tuple([import_zod4.z.string(), import_zod4.z.string()]), import_zod4.z.boolean())
   })
 ]);
 var IgnorePlugin = create2(
-  import_binding41.BuiltinPluginName.IgnorePlugin,
+  import_binding40.BuiltinPluginName.IgnorePlugin,
   (options) => {
     validate(options, IgnorePluginOptions);
     return options;
@@ -11368,22 +11602,22 @@ var IgnorePlugin = create2(
 );
 
 // src/builtin-plugin/InferAsyncModulesPlugin.ts
-var import_binding42 = require("@rspack/binding");
+var import_binding41 = require("@rspack/binding");
 var InferAsyncModulesPlugin = create2(
-  import_binding42.BuiltinPluginName.InferAsyncModulesPlugin,
+  import_binding41.BuiltinPluginName.InferAsyncModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/JavascriptModulesPlugin.ts
-var import_binding43 = require("@rspack/binding");
+var import_binding42 = require("@rspack/binding");
 var liteTapable4 = __toESM(require("@rspack/lite-tapable"));
 var compilationHooksMap3 = /* @__PURE__ */ new WeakMap();
 var JavascriptModulesPlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding43.BuiltinPluginName.JavascriptModulesPlugin;
+    this.name = import_binding42.BuiltinPluginName.JavascriptModulesPlugin;
     this.affectedHooks = "compilation";
   }
   raw() {
@@ -11407,18 +11641,18 @@ var JavascriptModulesPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/JsLoaderRspackPlugin.ts
-var import_binding44 = require("@rspack/binding");
+var import_binding43 = require("@rspack/binding");
 var JsLoaderRspackPlugin = create2(
-  import_binding44.BuiltinPluginName.JsLoaderRspackPlugin,
+  import_binding43.BuiltinPluginName.JsLoaderRspackPlugin,
   (compiler) => runLoaders.bind(null, compiler),
   /* Not Inheretable */
   "thisCompilation"
 );
 
 // src/builtin-plugin/JsonModulesPlugin.ts
-var import_binding45 = require("@rspack/binding");
+var import_binding44 = require("@rspack/binding");
 var JsonModulesPlugin = create2(
-  import_binding45.BuiltinPluginName.JsonModulesPlugin,
+  import_binding44.BuiltinPluginName.JsonModulesPlugin,
   () => {
   },
   "compilation"
@@ -11554,9 +11788,9 @@ function moduleImpl(args) {
 }
 
 // src/builtin-plugin/lazy-compilation/lazyCompilation.ts
-var import_binding46 = require("@rspack/binding");
+var import_binding45 = require("@rspack/binding");
 var BuiltinLazyCompilationPlugin = create2(
-  import_binding46.BuiltinPluginName.LazyCompilationPlugin,
+  import_binding45.BuiltinPluginName.LazyCompilationPlugin,
   (module2, cacheable, entries, imports, test) => ({ module: module2, cacheable, imports, entries, test }),
   "thisCompilation"
 );
@@ -11601,21 +11835,21 @@ var LazyCompilationPlugin = class {
 };
 
 // src/builtin-plugin/LimitChunkCountPlugin.ts
-var import_binding47 = require("@rspack/binding");
+var import_binding46 = require("@rspack/binding");
 var LimitChunkCountPlugin = create2(
-  import_binding47.BuiltinPluginName.LimitChunkCountPlugin,
+  import_binding46.BuiltinPluginName.LimitChunkCountPlugin,
   (options) => {
     return options;
   }
 );
 
 // src/builtin-plugin/MangleExportsPlugin.ts
-var import_binding48 = require("@rspack/binding");
+var import_binding47 = require("@rspack/binding");
 var MangleExportsPlugin = class extends RspackBuiltinPlugin {
   constructor(deterministic) {
     super();
     this.deterministic = deterministic;
-    this.name = import_binding48.BuiltinPluginName.MangleExportsPlugin;
+    this.name = import_binding47.BuiltinPluginName.MangleExportsPlugin;
     this.affectedHooks = "compilation";
   }
   raw(compiler) {
@@ -11646,27 +11880,27 @@ var MangleExportsPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/MergeDuplicateChunksPlugin.ts
-var import_binding49 = require("@rspack/binding");
+var import_binding48 = require("@rspack/binding");
 var MergeDuplicateChunksPlugin = create2(
-  import_binding49.BuiltinPluginName.MergeDuplicateChunksPlugin,
+  import_binding48.BuiltinPluginName.MergeDuplicateChunksPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/ModuleChunkFormatPlugin.ts
-var import_binding50 = require("@rspack/binding");
+var import_binding49 = require("@rspack/binding");
 var ModuleChunkFormatPlugin = create2(
-  import_binding50.BuiltinPluginName.ModuleChunkFormatPlugin,
+  import_binding49.BuiltinPluginName.ModuleChunkFormatPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/ModuleConcatenationPlugin.ts
-var import_binding51 = require("@rspack/binding");
+var import_binding50 = require("@rspack/binding");
 var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding51.BuiltinPluginName.ModuleConcatenationPlugin;
+    this.name = import_binding50.BuiltinPluginName.ModuleConcatenationPlugin;
     this.affectedHooks = "compilation";
   }
   raw(compiler) {
@@ -11697,52 +11931,52 @@ var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/NamedChunkIdsPlugin.ts
-var import_binding52 = require("@rspack/binding");
+var import_binding51 = require("@rspack/binding");
 var NamedChunkIdsPlugin = create2(
-  import_binding52.BuiltinPluginName.NamedChunkIdsPlugin,
+  import_binding51.BuiltinPluginName.NamedChunkIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/NamedModuleIdsPlugin.ts
-var import_binding53 = require("@rspack/binding");
+var import_binding52 = require("@rspack/binding");
 var NamedModuleIdsPlugin = create2(
-  import_binding53.BuiltinPluginName.NamedModuleIdsPlugin,
+  import_binding52.BuiltinPluginName.NamedModuleIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/NaturalChunkIdsPlugin.ts
-var import_binding54 = require("@rspack/binding");
+var import_binding53 = require("@rspack/binding");
 var NaturalChunkIdsPlugin = create2(
-  import_binding54.BuiltinPluginName.NaturalChunkIdsPlugin,
+  import_binding53.BuiltinPluginName.NaturalChunkIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/NaturalModuleIdsPlugin.ts
-var import_binding55 = require("@rspack/binding");
+var import_binding54 = require("@rspack/binding");
 var NaturalModuleIdsPlugin = create2(
-  import_binding55.BuiltinPluginName.NaturalModuleIdsPlugin,
+  import_binding54.BuiltinPluginName.NaturalModuleIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/NodeTargetPlugin.ts
-var import_binding56 = require("@rspack/binding");
+var import_binding55 = require("@rspack/binding");
 var NodeTargetPlugin = create2(
-  import_binding56.BuiltinPluginName.NodeTargetPlugin,
+  import_binding55.BuiltinPluginName.NodeTargetPlugin,
   () => void 0
 );
 
 // src/builtin-plugin/ProgressPlugin.ts
-var import_binding57 = require("@rspack/binding");
+var import_binding56 = require("@rspack/binding");
 var ProgressPlugin = create2(
-  import_binding57.BuiltinPluginName.ProgressPlugin,
+  import_binding56.BuiltinPluginName.ProgressPlugin,
   (progress = {}) => {
     if (typeof progress === "function") {
       return {
@@ -11756,9 +11990,9 @@ var ProgressPlugin = create2(
 );
 
 // src/builtin-plugin/ProvidePlugin.ts
-var import_binding58 = require("@rspack/binding");
+var import_binding57 = require("@rspack/binding");
 var ProvidePlugin = create2(
-  import_binding58.BuiltinPluginName.ProvidePlugin,
+  import_binding57.BuiltinPluginName.ProvidePlugin,
   (provide) => {
     const entries = Object.entries(provide).map(([key, value]) => {
       if (typeof value === "string") {
@@ -11771,53 +12005,53 @@ var ProvidePlugin = create2(
 );
 
 // src/builtin-plugin/RealContentHashPlugin.ts
-var import_binding59 = require("@rspack/binding");
+var import_binding58 = require("@rspack/binding");
 var RealContentHashPlugin = create2(
-  import_binding59.BuiltinPluginName.RealContentHashPlugin,
+  import_binding58.BuiltinPluginName.RealContentHashPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/RemoveEmptyChunksPlugin.ts
-var import_binding60 = require("@rspack/binding");
+var import_binding59 = require("@rspack/binding");
 var RemoveEmptyChunksPlugin = create2(
-  import_binding60.BuiltinPluginName.RemoveEmptyChunksPlugin,
+  import_binding59.BuiltinPluginName.RemoveEmptyChunksPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/RuntimeChunkPlugin.ts
-var import_binding61 = require("@rspack/binding");
+var import_binding60 = require("@rspack/binding");
 var RuntimeChunkPlugin = create2(
-  import_binding61.BuiltinPluginName.RuntimeChunkPlugin,
+  import_binding60.BuiltinPluginName.RuntimeChunkPlugin,
   (options) => options,
   "thisCompilation"
 );
 
 // src/builtin-plugin/RuntimePlugin.ts
-var import_binding62 = require("@rspack/binding");
+var import_binding61 = require("@rspack/binding");
 var RuntimePlugin = create2(
-  import_binding62.BuiltinPluginName.RuntimePlugin,
+  import_binding61.BuiltinPluginName.RuntimePlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/SideEffectsFlagPlugin.ts
-var import_binding63 = require("@rspack/binding");
+var import_binding62 = require("@rspack/binding");
 var SideEffectsFlagPlugin = create2(
-  import_binding63.BuiltinPluginName.SideEffectsFlagPlugin,
+  import_binding62.BuiltinPluginName.SideEffectsFlagPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/SizeLimitsPlugin.ts
-var import_binding64 = require("@rspack/binding");
+var import_binding63 = require("@rspack/binding");
 var SizeLimitsPlugin = create2(
-  import_binding64.BuiltinPluginName.SizeLimitsPlugin,
+  import_binding63.BuiltinPluginName.SizeLimitsPlugin,
   (options) => {
     const hints = options.hints === false ? void 0 : options.hints;
     return { ...options, hints };
@@ -11825,7 +12059,7 @@ var SizeLimitsPlugin = create2(
 );
 
 // src/builtin-plugin/SourceMapDevToolPlugin.ts
-var import_binding65 = require("@rspack/binding");
+var import_binding64 = require("@rspack/binding");
 
 // src/lib/ModuleFilenameHelpers.ts
 var ModuleFilenameHelpers_exports = {};
@@ -11868,7 +12102,7 @@ var matchObject = (obj, str) => {
 
 // src/builtin-plugin/SourceMapDevToolPlugin.ts
 var SourceMapDevToolPlugin = create2(
-  import_binding65.BuiltinPluginName.SourceMapDevToolPlugin,
+  import_binding64.BuiltinPluginName.SourceMapDevToolPlugin,
   (options) => {
     const { test, include, exclude, ...rest } = options;
     const rawOptions = rest;
@@ -11882,7 +12116,7 @@ var SourceMapDevToolPlugin = create2(
 
 // src/builtin-plugin/SplitChunksPlugin.ts
 var import_node_assert5 = __toESM(require("assert"));
-var import_binding66 = require("@rspack/binding");
+var import_binding65 = require("@rspack/binding");
 
 // src/util/SplitChunkSize.ts
 var JsSplitChunkSizes = class {
@@ -11905,7 +12139,7 @@ var SplitChunksPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
     this.options = options;
-    this.name = import_binding66.BuiltinPluginName.SplitChunksPlugin;
+    this.name = import_binding65.BuiltinPluginName.SplitChunksPlugin;
     this.affectedHooks = "thisCompilation";
   }
   raw(compiler) {
@@ -12011,12 +12245,12 @@ function toRawSplitChunksOptions(sc, compiler) {
 }
 
 // src/builtin-plugin/LightningCssMinimizerRspackPlugin.ts
-var import_binding67 = require("@rspack/binding");
+var import_binding66 = require("@rspack/binding");
 var LightningCssMinimizerRspackPlugin = create2(
-  import_binding67.BuiltinPluginName.LightningCssMinimizerRspackPlugin,
+  import_binding66.BuiltinPluginName.LightningCssMinimizerRspackPlugin,
   (options) => {
     var _a, _b, _c;
-    const { include, exclude, draft, nonStandard, pseudoClasses } = (options == null ? void 0 : options.minimizerOptions) ?? {};
+    const { include, exclude, draft, nonStandard, pseudoClasses, drafts } = (options == null ? void 0 : options.minimizerOptions) ?? {};
     const targets = ((_a = options == null ? void 0 : options.minimizerOptions) == null ? void 0 : _a.targets) ?? "fully supports es6";
     return {
       test: options == null ? void 0 : options.test,
@@ -12030,6 +12264,7 @@ var LightningCssMinimizerRspackPlugin = create2(
         exclude: exclude ? toFeatures(exclude) : void 0,
         targets: typeof targets === "string" ? [targets] : targets,
         draft: draft ? { customMedia: draft.customMedia ?? false } : void 0,
+        drafts: drafts ? { customMedia: drafts.customMedia ?? false } : void 0,
         nonStandard: nonStandard ? {
           deepSelectorCombinator: nonStandard.deepSelectorCombinator ?? false
         } : void 0,
@@ -12040,16 +12275,16 @@ var LightningCssMinimizerRspackPlugin = create2(
 );
 
 // src/builtin-plugin/RemoveDuplicateModulesPlugin.ts
-var import_binding68 = require("@rspack/binding");
+var import_binding67 = require("@rspack/binding");
 var RemoveDuplicateModulesPlugin = create2(
-  import_binding68.BuiltinPluginName.RemoveDuplicateModulesPlugin,
+  import_binding67.BuiltinPluginName.RemoveDuplicateModulesPlugin,
   () => {
     return {};
   }
 );
 
 // src/builtin-plugin/SwcJsMinimizerPlugin.ts
-var import_binding69 = require("@rspack/binding");
+var import_binding68 = require("@rspack/binding");
 function isObject2(value) {
   const type = typeof value;
   return value != null && (type === "object" || type === "function");
@@ -12092,7 +12327,7 @@ function getRawExtractCommentsOptions(extractComments) {
   return void 0;
 }
 var SwcJsMinimizerRspackPlugin = create2(
-  import_binding69.BuiltinPluginName.SwcJsMinimizerRspackPlugin,
+  import_binding68.BuiltinPluginName.SwcJsMinimizerRspackPlugin,
   (options) => {
     var _a, _b, _c, _d, _e;
     let compress = ((_a = options == null ? void 0 : options.minimizerOptions) == null ? void 0 : _a.compress) ?? true;
@@ -12131,23 +12366,23 @@ var SwcJsMinimizerRspackPlugin = create2(
 );
 
 // src/builtin-plugin/WarnCaseSensitiveModulesPlugin.ts
-var import_binding70 = require("@rspack/binding");
+var import_binding69 = require("@rspack/binding");
 var WarnCaseSensitiveModulesPlugin = create2(
-  import_binding70.BuiltinPluginName.WarnCaseSensitiveModulesPlugin,
+  import_binding69.BuiltinPluginName.WarnCaseSensitiveModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/WebWorkerTemplatePlugin.ts
-var import_binding71 = require("@rspack/binding");
+var import_binding70 = require("@rspack/binding");
 var WebWorkerTemplatePlugin = create2(
-  import_binding71.BuiltinPluginName.WebWorkerTemplatePlugin,
+  import_binding70.BuiltinPluginName.WebWorkerTemplatePlugin,
   () => void 0
 );
 
 // src/builtin-plugin/WorkerPlugin.ts
-var import_binding72 = require("@rspack/binding");
+var import_binding71 = require("@rspack/binding");
 var WorkerPlugin = class extends RspackBuiltinPlugin {
   constructor(chunkLoading2, wasmLoading2, module2, workerPublicPath2) {
     super();
@@ -12155,7 +12390,7 @@ var WorkerPlugin = class extends RspackBuiltinPlugin {
     this.wasmLoading = wasmLoading2;
     this.module = module2;
     this.workerPublicPath = workerPublicPath2;
-    this.name = import_binding72.BuiltinPluginName.WorkerPlugin;
+    this.name = import_binding71.BuiltinPluginName.WorkerPlugin;
   }
   raw(compiler) {
     if (this.chunkLoading) {
@@ -12169,25 +12404,25 @@ var WorkerPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/FetchCompileAsyncWasmPlugin.ts
-var import_binding73 = require("@rspack/binding");
+var import_binding72 = require("@rspack/binding");
 var FetchCompileAsyncWasmPlugin = create2(
-  import_binding73.BuiltinPluginName.FetchCompileAsyncWasmPlugin,
+  import_binding72.BuiltinPluginName.FetchCompileAsyncWasmPlugin,
   () => {
   },
   "thisCompilation"
 );
 
 // src/builtin-plugin/NoEmitOnErrorsPlugin.ts
-var import_binding74 = require("@rspack/binding");
+var import_binding73 = require("@rspack/binding");
 var NoEmitOnErrorsPlugin = create2(
-  import_binding74.BuiltinPluginName.NoEmitOnErrorsPlugin,
+  import_binding73.BuiltinPluginName.NoEmitOnErrorsPlugin,
   () => void 0
 );
 
 // src/builtin-plugin/ContextReplacementPlugin.ts
-var import_binding75 = require("@rspack/binding");
+var import_binding74 = require("@rspack/binding");
 var ContextReplacementPlugin = create2(
-  import_binding75.BuiltinPluginName.ContextReplacementPlugin,
+  import_binding74.BuiltinPluginName.ContextReplacementPlugin,
   (resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) => {
     const rawOptions = {
       resourceRegExp
@@ -12216,19 +12451,56 @@ var ContextReplacementPlugin = create2(
   }
 );
 
-// src/ContextModuleFactory.ts
-var liteTapable5 = __toESM(require("@rspack/lite-tapable"));
-var ContextModuleFactory = class {
-  constructor() {
-    this.hooks = {
-      beforeResolve: new liteTapable5.AsyncSeriesWaterfallHook(["resolveData"]),
-      afterResolve: new liteTapable5.AsyncSeriesWaterfallHook(["resolveData"])
+// src/builtin-plugin/LibManifestPlugin.ts
+var import_binding75 = require("@rspack/binding");
+var LibManifestPlugin = create2(
+  import_binding75.BuiltinPluginName.LibManifestPlugin,
+  (options) => {
+    const { context: context2, entryOnly, format: format3, name: name2, path: path10, type } = options;
+    return {
+      context: context2,
+      entryOnly,
+      format: format3,
+      name: name2,
+      path: path10,
+      type
     };
   }
-};
+);
 
-// src/FileSystem.ts
-var import_node_util4 = __toESM(require("util"));
+// src/builtin-plugin/DllEntryPlugin.ts
+var import_binding76 = require("@rspack/binding");
+var DllEntryPlugin = create2(
+  import_binding76.BuiltinPluginName.DllEntryPlugin,
+  (context2, entries, options) => {
+    return {
+      context: context2,
+      entries,
+      name: options.name
+    };
+  }
+);
+
+// src/builtin-plugin/DllReferenceAgencyPlugin.ts
+var import_binding77 = require("@rspack/binding");
+var DllReferenceAgencyPlugin = create2(
+  import_binding77.BuiltinPluginName.DllReferenceAgencyPlugin,
+  (options) => options
+);
+
+// src/ContextModuleFactory.ts
+var liteTapable5 = __toESM(require("@rspack/lite-tapable"));
+var ContextModuleFactory = class {
+  constructor() {
+    this.hooks = {
+      beforeResolve: new liteTapable5.AsyncSeriesWaterfallHook(["resolveData"]),
+      afterResolve: new liteTapable5.AsyncSeriesWaterfallHook(["resolveData"])
+    };
+  }
+};
+
+// src/FileSystem.ts
+var import_node_util4 = __toESM(require("util"));
 
 // src/util/fs.ts
 var import_node_assert6 = __toESM(require("assert"));
@@ -12937,6 +13209,11 @@ var Compiler = class _Compiler {
     this.watchMode = false;
     new JsLoaderRspackPlugin(this).apply(this);
     new ExecuteModulePlugin().apply(this);
+    this.hooks.shutdown.tap("rspack:cleanup", () => {
+      if (!this.running) {
+        this.#instance = void 0;
+      }
+    });
   }
   get recordsInputPath() {
     return unsupported("Compiler.recordsInputPath");
@@ -13371,465 +13648,797 @@ var Compiler = class _Compiler {
       this.#ruleSet.builtinReferences.entries()
     );
     const instanceBinding = require("@rspack/binding");
+    const that = new WeakRef(this);
     this.#registers = {
       registerCompilerThisCompilationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerThisCompilation,
-        () => this.hooks.thisCompilation,
-        (queried) => (native) => {
-          this.#createCompilation(native);
-          queried.call(this.#compilation, this.#compilationParams);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.thisCompilation;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(native) {
+            that.deref().#createCompilation(native);
+            return queried.call(
+              that.deref().#compilation,
+              that.deref().#compilationParams
+            );
+          };
         }
       ),
       registerCompilerCompilationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerCompilation,
-        () => this.hooks.compilation,
-        (queried) => () => queried.call(this.#compilation, this.#compilationParams)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.compilation;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(
+              that.deref().#compilation,
+              that.deref().#compilationParams
+            );
+          };
+        }
       ),
       registerCompilerMakeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerMake,
-        () => this.hooks.make,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.make;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerFinishMakeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerFinishMake,
-        () => this.hooks.finishMake,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.finishMake;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerShouldEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerShouldEmit,
-        () => this.hooks.shouldEmit,
-        (queried) => () => queried.call(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.shouldEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerEmit,
-        () => this.hooks.emit,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.emit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerAfterEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerAfterEmit,
-        () => this.hooks.afterEmit,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.afterEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerAssetEmittedTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerAssetEmitted,
-        () => this.hooks.assetEmitted,
-        (queried) => async ({
-          filename: filename2,
-          targetPath,
-          outputPath
-        }) => {
-          return queried.promise(filename2, {
-            compilation: this.#compilation,
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.assetEmitted;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function({
+            filename: filename2,
             targetPath,
-            outputPath,
-            get source() {
-              var _a;
-              return (_a = this.compilation.getAsset(filename2)) == null ? void 0 : _a.source;
-            },
-            get content() {
-              var _a;
-              return (_a = this.source) == null ? void 0 : _a.buffer();
-            }
-          });
+            outputPath
+          }) {
+            return queried.promise(filename2, {
+              compilation: that.deref().#compilation,
+              targetPath,
+              outputPath,
+              get source() {
+                var _a;
+                return (_a = that.deref().#compilation.getAsset(filename2)) == null ? void 0 : _a.source;
+              },
+              get content() {
+                var _a;
+                return (_a = this.source) == null ? void 0 : _a.buffer();
+              }
+            });
+          };
         }
       ),
       registerCompilationAdditionalTreeRuntimeRequirements: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAdditionalTreeRuntimeRequirements,
-        () => this.#compilation.hooks.additionalTreeRuntimeRequirements,
-        (queried) => ({
-          chunk,
-          runtimeRequirements
-        }) => {
-          const set = __from_binding_runtime_globals(runtimeRequirements);
-          queried.call(
-            Chunk.__from_binding(chunk, this.#compilation),
-            set
-          );
-          return {
-            runtimeRequirements: __to_binding_runtime_globals(set)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.additionalTreeRuntimeRequirements;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({
+            chunk,
+            runtimeRequirements
+          }) {
+            const set = __from_binding_runtime_globals(runtimeRequirements);
+            queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              set
+            );
+            return {
+              runtimeRequirements: __to_binding_runtime_globals(set)
+            };
           };
         }
       ),
       registerCompilationRuntimeRequirementInTree: this.#createHookMapRegisterTaps(
         binding2.RegisterJsTapKind.CompilationRuntimeRequirementInTree,
-        () => this.#compilation.hooks.runtimeRequirementInTree,
-        (queried) => ({
-          chunk: rawChunk,
-          runtimeRequirements
-        }) => {
-          const set = __from_binding_runtime_globals(runtimeRequirements);
-          const chunk = Chunk.__from_binding(rawChunk, this.#compilation);
-          for (const r of set) {
-            queried.for(r).call(chunk, set);
-          }
-          return {
-            runtimeRequirements: __to_binding_runtime_globals(set)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.runtimeRequirementInTree;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({
+            chunk: rawChunk,
+            runtimeRequirements
+          }) {
+            const set = __from_binding_runtime_globals(runtimeRequirements);
+            const chunk = Chunk.__from_binding(
+              rawChunk,
+              that.deref().#compilation
+            );
+            for (const r of set) {
+              queried.for(r).call(chunk, set);
+            }
+            return {
+              runtimeRequirements: __to_binding_runtime_globals(set)
+            };
           };
         }
       ),
       registerCompilationRuntimeModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationRuntimeModule,
-        () => this.#compilation.hooks.runtimeModule,
-        (queried) => ({ module: module2, chunk }) => {
-          var _a, _b;
-          const originSource = (_a = module2.source) == null ? void 0 : _a.source;
-          queried.call(
-            module2,
-            Chunk.__from_binding(chunk, this.#compilation)
-          );
-          const newSource = (_b = module2.source) == null ? void 0 : _b.source;
-          if (newSource && newSource !== originSource) {
-            return module2;
-          }
-          return;
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.runtimeModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({ module: module2, chunk }) {
+            var _a, _b;
+            const originSource = (_a = module2.source) == null ? void 0 : _a.source;
+            queried.call(
+              module2,
+              Chunk.__from_binding(chunk, that.deref().#compilation)
+            );
+            const newSource = (_b = module2.source) == null ? void 0 : _b.source;
+            if (newSource && newSource !== originSource) {
+              return module2;
+            }
+            return;
+          };
         }
       ),
       registerCompilationBuildModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationBuildModule,
-        () => this.#compilation.hooks.buildModule,
-        (queired) => (m) => queired.call(Module.__from_binding(m, this.#compilation))
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.buildModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(m) {
+            return queried.call(
+              Module.__from_binding(m, that.deref().#compilation)
+            );
+          };
+        }
       ),
       registerCompilationStillValidModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationStillValidModule,
-        () => this.#compilation.hooks.stillValidModule,
-        (queired) => (m) => queired.call(Module.__from_binding(m, this.#compilation))
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.stillValidModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(m) {
+            return queried.call(
+              Module.__from_binding(m, that.deref().#compilation)
+            );
+          };
+        }
       ),
       registerCompilationSucceedModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationSucceedModule,
-        () => this.#compilation.hooks.succeedModule,
-        (queired) => (m) => queired.call(Module.__from_binding(m, this.#compilation))
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.succeedModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(m) {
+            return queried.call(
+              Module.__from_binding(m, that.deref().#compilation)
+            );
+          };
+        }
       ),
       registerCompilationExecuteModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationExecuteModule,
-        () => this.#compilation.hooks.executeModule,
-        (queried) => ({
-          entry: entry2,
-          id,
-          codegenResults,
-          runtimeModules
-        }) => {
-          const __webpack_require__ = (id2) => {
-            const cached = moduleCache[id2];
-            if (cached !== void 0) {
-              if (cached.error) throw cached.error;
-              return cached.exports;
-            }
-            const execOptions = {
-              id: id2,
-              module: {
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.executeModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({
+            entry: entry2,
+            id,
+            codegenResults,
+            runtimeModules
+          }) {
+            const __webpack_require__ = (id2) => {
+              const cached = moduleCache[id2];
+              if (cached !== void 0) {
+                if (cached.error) throw cached.error;
+                return cached.exports;
+              }
+              const execOptions = {
                 id: id2,
-                exports: {},
-                loaded: false,
-                error: void 0
-              },
-              require: __webpack_require__
+                module: {
+                  id: id2,
+                  exports: {},
+                  loaded: false,
+                  error: void 0
+                },
+                require: __webpack_require__
+              };
+              for (const handler of interceptModuleExecution) {
+                handler(execOptions);
+              }
+              const result2 = codegenResults.map[id2]["build time"];
+              const moduleObject = execOptions.module;
+              if (id2) moduleCache[id2] = moduleObject;
+              tryRunOrWebpackError(
+                () => queried.call(
+                  {
+                    codeGenerationResult: new CodeGenerationResult(result2),
+                    moduleObject
+                  },
+                  { __webpack_require__ }
+                ),
+                "Compilation.hooks.executeModule"
+              );
+              moduleObject.loaded = true;
+              return moduleObject.exports;
             };
-            for (const handler of interceptModuleExecution) {
-              handler(execOptions);
+            const moduleCache = __webpack_require__[RuntimeGlobals.moduleCache.replace(
+              `${RuntimeGlobals.require}.`,
+              ""
+            )] = {};
+            const interceptModuleExecution = __webpack_require__[RuntimeGlobals.interceptModuleExecution.replace(
+              `${RuntimeGlobals.require}.`,
+              ""
+            )] = [];
+            for (const runtimeModule of runtimeModules) {
+              __webpack_require__(runtimeModule);
             }
-            const result2 = codegenResults.map[id2]["build time"];
-            const moduleObject = execOptions.module;
-            if (id2) moduleCache[id2] = moduleObject;
-            tryRunOrWebpackError(
-              () => queried.call(
-                {
-                  codeGenerationResult: new CodeGenerationResult(result2),
-                  moduleObject
-                },
-                { __webpack_require__ }
-              ),
-              "Compilation.hooks.executeModule"
-            );
-            moduleObject.loaded = true;
-            return moduleObject.exports;
+            const executeResult = __webpack_require__(entry2);
+            that.deref().#moduleExecutionResultsMap.set(id, executeResult);
           };
-          const moduleCache = __webpack_require__[RuntimeGlobals.moduleCache.replace(
-            `${RuntimeGlobals.require}.`,
-            ""
-          )] = {};
-          const interceptModuleExecution = __webpack_require__[RuntimeGlobals.interceptModuleExecution.replace(
-            `${RuntimeGlobals.require}.`,
-            ""
-          )] = [];
-          for (const runtimeModule of runtimeModules) {
-            __webpack_require__(runtimeModule);
-          }
-          const executeResult = __webpack_require__(entry2);
-          this.#moduleExecutionResultsMap.set(id, executeResult);
         }
       ),
       registerCompilationFinishModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationFinishModules,
-        () => this.#compilation.hooks.finishModules,
-        (queried) => async () => await queried.promise(this.#compilation.modules)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.finishModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation.modules);
+          };
+        }
       ),
       registerCompilationOptimizeModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeModules,
-        () => this.#compilation.hooks.optimizeModules,
-        (queried) => () => queried.call(this.#compilation.modules.values())
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.optimizeModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(that.deref().#compilation.modules.values());
+          };
+        }
       ),
       registerCompilationAfterOptimizeModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterOptimizeModules,
-        () => this.#compilation.hooks.afterOptimizeModules,
-        (queried) => () => {
-          queried.call(this.#compilation.modules.values());
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.afterOptimizeModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            queried.call(that.deref().#compilation.modules.values());
+          };
         }
       ),
       registerCompilationOptimizeTreeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeTree,
-        () => this.#compilation.hooks.optimizeTree,
-        (queried) => async () => await queried.promise(
-          this.#compilation.chunks,
-          this.#compilation.modules
-        )
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.optimizeTree;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(
+              that.deref().#compilation.chunks,
+              that.deref().#compilation.modules
+            );
+          };
+        }
       ),
       registerCompilationOptimizeChunkModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeChunkModules,
-        () => this.#compilation.hooks.optimizeChunkModules,
-        (queried) => async () => await queried.promise(
-          this.#compilation.chunks,
-          this.#compilation.modules
-        )
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.optimizeChunkModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(
+              that.deref().#compilation.chunks,
+              that.deref().#compilation.modules
+            );
+          };
+        }
       ),
       registerCompilationChunkHashTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationChunkHash,
-        () => this.#compilation.hooks.chunkHash,
-        (queried) => (chunk) => {
-          if (!this.options.output.hashFunction) {
-            throw new Error("'output.hashFunction' cannot be undefined");
-          }
-          const hash = createHash(this.options.output.hashFunction);
-          queried.call(Chunk.__from_binding(chunk, this.#compilation), hash);
-          const digestResult = hash.digest(this.options.output.hashDigest);
-          return Buffer.from(digestResult);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.chunkHash;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(chunk) {
+            if (!that.deref().options.output.hashFunction) {
+              throw new Error("'output.hashFunction' cannot be undefined");
+            }
+            const hash = createHash(that.deref().options.output.hashFunction);
+            queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              hash
+            );
+            const digestResult = hash.digest(
+              that.deref().options.output.hashDigest
+            );
+            return Buffer.from(digestResult);
+          };
         }
       ),
       registerCompilationChunkAssetTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationChunkAsset,
-        () => this.#compilation.hooks.chunkAsset,
-        (queried) => ({ chunk, filename: filename2 }) => queried.call(
-          Chunk.__from_binding(chunk, this.#compilation),
-          filename2
-        )
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.chunkAsset;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({ chunk, filename: filename2 }) {
+            return queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              filename2
+            );
+          };
+        }
       ),
       registerCompilationProcessAssetsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationProcessAssets,
-        () => this.#compilation.hooks.processAssets,
-        (queried) => async () => await queried.promise(this.#compilation.assets)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.processAssets;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation.assets);
+          };
+        }
       ),
       registerCompilationAfterProcessAssetsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterProcessAssets,
-        () => this.#compilation.hooks.afterProcessAssets,
-        (queried) => () => queried.call(this.#compilation.assets)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.afterProcessAssets;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(that.deref().#compilation.assets);
+          };
+        }
       ),
       registerCompilationSealTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationSeal,
-        () => this.#compilation.hooks.seal,
-        (queried) => () => queried.call()
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.seal;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call();
+          };
+        }
       ),
       registerCompilationAfterSealTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterSeal,
-        () => this.#compilation.hooks.afterSeal,
-        (queried) => async () => await queried.promise()
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.afterSeal;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise();
+          };
+        }
       ),
       registerNormalModuleFactoryBeforeResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryBeforeResolve,
-        () => this.#compilationParams.normalModuleFactory.hooks.beforeResolve,
-        (queried) => async (resolveData) => {
-          const normalizedResolveData = {
-            contextInfo: {
-              issuer: resolveData.issuer
-            },
-            request: resolveData.request,
-            context: resolveData.context,
-            fileDependencies: [],
-            missingDependencies: [],
-            contextDependencies: []
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.beforeResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(resolveData) {
+            const normalizedResolveData = {
+              contextInfo: {
+                issuer: resolveData.issuer
+              },
+              request: resolveData.request,
+              context: resolveData.context,
+              fileDependencies: [],
+              missingDependencies: [],
+              contextDependencies: []
+            };
+            const ret = await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return [ret, resolveData];
           };
-          const ret = await queried.promise(normalizedResolveData);
-          resolveData.request = normalizedResolveData.request;
-          resolveData.context = normalizedResolveData.context;
-          return [ret, resolveData];
         }
       ),
       registerNormalModuleFactoryFactorizeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryFactorize,
-        () => this.#compilationParams.normalModuleFactory.hooks.factorize,
-        (queried) => async (resolveData) => {
-          const normalizedResolveData = {
-            contextInfo: {
-              issuer: resolveData.issuer
-            },
-            request: resolveData.request,
-            context: resolveData.context,
-            fileDependencies: [],
-            missingDependencies: [],
-            contextDependencies: []
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.factorize;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(resolveData) {
+            const normalizedResolveData = {
+              contextInfo: {
+                issuer: resolveData.issuer
+              },
+              request: resolveData.request,
+              context: resolveData.context,
+              fileDependencies: [],
+              missingDependencies: [],
+              contextDependencies: []
+            };
+            await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return resolveData;
           };
-          await queried.promise(normalizedResolveData);
-          resolveData.request = normalizedResolveData.request;
-          resolveData.context = normalizedResolveData.context;
-          return resolveData;
         }
       ),
       registerNormalModuleFactoryResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryResolve,
-        () => this.#compilationParams.normalModuleFactory.hooks.resolve,
-        (queried) => async (resolveData) => {
-          const normalizedResolveData = {
-            contextInfo: {
-              issuer: resolveData.issuer
-            },
-            request: resolveData.request,
-            context: resolveData.context,
-            fileDependencies: [],
-            missingDependencies: [],
-            contextDependencies: []
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.resolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(resolveData) {
+            const normalizedResolveData = {
+              contextInfo: {
+                issuer: resolveData.issuer
+              },
+              request: resolveData.request,
+              context: resolveData.context,
+              fileDependencies: [],
+              missingDependencies: [],
+              contextDependencies: []
+            };
+            await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return resolveData;
           };
-          await queried.promise(normalizedResolveData);
-          resolveData.request = normalizedResolveData.request;
-          resolveData.context = normalizedResolveData.context;
-          return resolveData;
         }
       ),
       registerNormalModuleFactoryResolveForSchemeTaps: this.#createHookMapRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryResolveForScheme,
-        () => this.#compilationParams.normalModuleFactory.hooks.resolveForScheme,
-        (queried) => async (args) => {
-          const ret = await queried.for(args.scheme).promise(args.resourceData);
-          return [ret, args.resourceData];
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.resolveForScheme;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(args) {
+            const ret = await queried.for(args.scheme).promise(args.resourceData);
+            return [ret, args.resourceData];
+          };
         }
       ),
       registerNormalModuleFactoryAfterResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryAfterResolve,
-        () => this.#compilationParams.normalModuleFactory.hooks.afterResolve,
-        (queried) => async (arg) => {
-          const data = {
-            contextInfo: {
-              issuer: arg.issuer
-            },
-            request: arg.request,
-            context: arg.context,
-            fileDependencies: arg.fileDependencies,
-            missingDependencies: arg.missingDependencies,
-            contextDependencies: arg.contextDependencies,
-            createData: arg.createData
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.afterResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(arg) {
+            const data = {
+              contextInfo: {
+                issuer: arg.issuer
+              },
+              request: arg.request,
+              context: arg.context,
+              fileDependencies: arg.fileDependencies,
+              missingDependencies: arg.missingDependencies,
+              contextDependencies: arg.contextDependencies,
+              createData: arg.createData
+            };
+            const ret = await queried.promise(data);
+            return [ret, data.createData];
           };
-          const ret = await queried.promise(data);
-          return [ret, data.createData];
         }
       ),
       registerNormalModuleFactoryCreateModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryCreateModule,
-        () => this.#compilationParams.normalModuleFactory.hooks.createModule,
-        (queried) => async (args) => {
-          const data = {
-            ...args,
-            settings: {}
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.createModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(args) {
+            const data = {
+              ...args,
+              settings: {}
+            };
+            await queried.promise(data, {});
           };
-          await queried.promise(data, {});
         }
       ),
       registerContextModuleFactoryBeforeResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.ContextModuleFactoryBeforeResolve,
-        () => this.#compilationParams.contextModuleFactory.hooks.beforeResolve,
-        (queried) => async (bindingData) => {
-          const data = bindingData ? ContextModuleFactoryBeforeResolveData.__from_binding(
-            bindingData
-          ) : false;
-          const result2 = await queried.promise(data);
-          return result2 ? ContextModuleFactoryBeforeResolveData.__to_binding(result2) : false;
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.contextModuleFactory.hooks.beforeResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(bindingData) {
+            const data = bindingData ? ContextModuleFactoryBeforeResolveData.__from_binding(
+              bindingData
+            ) : false;
+            const result2 = await queried.promise(data);
+            return result2 ? ContextModuleFactoryBeforeResolveData.__to_binding(result2) : false;
+          };
         }
       ),
       registerContextModuleFactoryAfterResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.ContextModuleFactoryAfterResolve,
-        () => this.#compilationParams.contextModuleFactory.hooks.afterResolve,
-        (queried) => async (bindingData) => {
-          const data = bindingData ? ContextModuleFactoryAfterResolveData.__from_binding(
-            bindingData
-          ) : false;
-          const result2 = await queried.promise(data);
-          return result2 ? ContextModuleFactoryAfterResolveData.__to_binding(result2) : false;
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.contextModuleFactory.hooks.afterResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(bindingData) {
+            const data = bindingData ? ContextModuleFactoryAfterResolveData.__from_binding(
+              bindingData
+            ) : false;
+            const result2 = await queried.promise(data);
+            return result2 ? ContextModuleFactoryAfterResolveData.__to_binding(result2) : false;
+          };
         }
       ),
       registerJavascriptModulesChunkHashTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.JavascriptModulesChunkHash,
-        () => JavascriptModulesPlugin.getCompilationHooks(this.#compilation).chunkHash,
-        (queried) => (chunk) => {
-          if (!this.options.output.hashFunction) {
-            throw new Error("'output.hashFunction' cannot be undefined");
-          }
-          const hash = createHash(this.options.output.hashFunction);
-          queried.call(Chunk.__from_binding(chunk, this.#compilation), hash);
-          const digestResult = hash.digest(this.options.output.hashDigest);
-          return Buffer.from(digestResult);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return JavascriptModulesPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).chunkHash;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(chunk) {
+            if (!that.deref().options.output.hashFunction) {
+              throw new Error("'output.hashFunction' cannot be undefined");
+            }
+            const hash = createHash(that.deref().options.output.hashFunction);
+            queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              hash
+            );
+            const digestResult = hash.digest(
+              that.deref().options.output.hashDigest
+            );
+            return Buffer.from(digestResult);
+          };
         }
       ),
       registerHtmlPluginBeforeAssetTagGenerationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginBeforeAssetTagGeneration,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).beforeAssetTagGeneration,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).beforeAssetTagGeneration;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginAlterAssetTagsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAlterAssetTags,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).alterAssetTags,
-        (queried) => async (data) => {
-          return await queried.promise(data);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).alterAssetTags;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise(data);
+          };
         }
       ),
       registerHtmlPluginAlterAssetTagGroupsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAlterAssetTagGroups,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).alterAssetTagGroups,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).alterAssetTagGroups;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginAfterTemplateExecutionTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAfterTemplateExecution,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).afterTemplateExecution,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).afterTemplateExecution;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginBeforeEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginBeforeEmit,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).beforeEmit,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).beforeEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginAfterEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAfterEmit,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).afterEmit,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).afterEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       )
     };
@@ -13878,7 +14487,9 @@ var Compiler = class _Compiler {
     }
   }
   #createHookRegisterTaps(registerKind, getHook, createTap) {
+    const that = new WeakRef(this);
     const getTaps = (stages) => {
+      const compiler = that.deref();
       const hook = getHook();
       if (!hook.isUsed()) return [];
       const breakpoints = [
@@ -13898,7 +14509,7 @@ var Compiler = class _Compiler {
           stage: liteTapable7.safeStage(from + 1)
         });
       }
-      this.#decorateJsTaps(jsTaps);
+      compiler.#decorateJsTaps(jsTaps);
       return jsTaps;
     };
     getTaps.registerKind = registerKind;
@@ -13906,7 +14517,9 @@ var Compiler = class _Compiler {
     return getTaps;
   }
   #createHookMapRegisterTaps(registerKind, getHookMap, createTap) {
+    const that = new WeakRef(this);
     const getTaps = (stages) => {
+      const compiler = that.deref();
       const map = getHookMap();
       if (!map.isUsed()) return [];
       const breakpoints = [
@@ -13926,7 +14539,7 @@ var Compiler = class _Compiler {
           stage: liteTapable7.safeStage(from + 1)
         });
       }
-      this.#decorateJsTaps(jsTaps);
+      compiler.#decorateJsTaps(jsTaps);
       return jsTaps;
     };
     getTaps.registerKind = registerKind;
@@ -17755,6 +18368,203 @@ var RspackOptionsApply = class {
   }
 };
 
+// src/lib/DllPlugin.ts
+var import_zod5 = __toESM(require("../compiled/zod/index.js"));
+
+// src/builtin-plugin/FlagAllModulesAsUsedPlugin.ts
+var import_binding78 = require("@rspack/binding");
+var FlagAllModulesAsUsedPlugin = create2(
+  import_binding78.BuiltinPluginName.FlagAllModulesAsUsedPlugin,
+  (explanation) => {
+    return {
+      explanation
+    };
+  }
+);
+
+// src/lib/DllPlugin.ts
+var dllPluginOptions = import_zod5.default.object({
+  context: import_zod5.default.string().optional(),
+  entryOnly: import_zod5.default.boolean().optional(),
+  format: import_zod5.default.boolean().optional(),
+  name: import_zod5.default.string().optional(),
+  path: import_zod5.default.string(),
+  type: import_zod5.default.string().optional()
+});
+var DllPlugin = class _DllPlugin {
+  constructor(options) {
+    validate(options, dllPluginOptions);
+    this.options = {
+      ...options,
+      entryOnly: options.entryOnly !== false
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.entryOption.tap(_DllPlugin.name, (context2, entry2) => {
+      if (typeof entry2 === "function") {
+        throw new Error(
+          "DllPlugin doesn't support dynamic entry (function) yet"
+        );
+      }
+      for (const name2 of Object.keys(entry2)) {
+        const options = {
+          name: name2
+        };
+        const entries = entry2[name2].import || [];
+        new DllEntryPlugin(context2, entries, options).apply(compiler);
+      }
+      return true;
+    });
+    new LibManifestPlugin(this.options).apply(compiler);
+    if (!this.options.entryOnly) {
+      new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
+    }
+  }
+};
+
+// src/lib/DllReferencePlugin.ts
+var import_zod6 = __toESM(require("../compiled/zod/index.js"));
+var dllReferencePluginOptionsContentItem = import_zod6.default.object({
+  buildMeta: import_zod6.default.custom().optional(),
+  exports: import_zod6.default.array(import_zod6.default.string()).or(import_zod6.default.literal(true)).optional(),
+  id: import_zod6.default.string().optional()
+});
+var dllReferencePluginOptionsContent = import_zod6.default.record(
+  dllReferencePluginOptionsContentItem
+);
+var dllReferencePluginOptionsSourceType = import_zod6.default.enum([
+  "var",
+  "assign",
+  "this",
+  "window",
+  "global",
+  "commonjs",
+  "commonjs2",
+  "commonjs-module",
+  "amd",
+  "amd-require",
+  "umd",
+  "umd2",
+  "jsonp",
+  "system"
+]);
+var dllReferencePluginOptionsManifest = import_zod6.default.object({
+  content: dllReferencePluginOptionsContent,
+  name: import_zod6.default.string().optional(),
+  type: dllReferencePluginOptionsSourceType.optional()
+});
+var dllReferencePluginOptions = import_zod6.default.union([
+  import_zod6.default.object({
+    context: import_zod6.default.string().optional(),
+    extensions: import_zod6.default.array(import_zod6.default.string()).optional(),
+    manifest: import_zod6.default.string().or(dllReferencePluginOptionsManifest),
+    name: import_zod6.default.string().optional(),
+    scope: import_zod6.default.string().optional(),
+    sourceType: dllReferencePluginOptionsSourceType.optional(),
+    type: import_zod6.default.enum(["require", "object"]).optional()
+  }),
+  import_zod6.default.object({
+    content: dllReferencePluginOptionsContent,
+    context: import_zod6.default.string().optional(),
+    extensions: import_zod6.default.array(import_zod6.default.string()).optional(),
+    name: import_zod6.default.string(),
+    scope: import_zod6.default.string().optional(),
+    sourceType: dllReferencePluginOptionsSourceType.optional(),
+    type: import_zod6.default.enum(["require", "object"]).optional()
+  })
+]);
+var DllReferencePlugin = class _DllReferencePlugin {
+  constructor(options) {
+    validate(options, dllReferencePluginOptions);
+    this.options = options;
+    this.errors = /* @__PURE__ */ new WeakMap();
+  }
+  apply(compiler) {
+    compiler.hooks.beforeCompile.tapPromise(
+      _DllReferencePlugin.name,
+      async (params) => {
+        const manifest = await new Promise((resolve2, reject) => {
+          var _a;
+          if ("manifest" in this.options) {
+            const manifest2 = this.options.manifest;
+            if (typeof manifest2 === "string") {
+              const manifestParameter = manifest2;
+              (_a = compiler.inputFileSystem) == null ? void 0 : _a.readFile(
+                manifestParameter,
+                "utf8",
+                (err, result2) => {
+                  if (err) return reject(err);
+                  if (!result2)
+                    return reject(
+                      new DllManifestError(
+                        manifestParameter,
+                        `Can't read anything from ${manifestParameter}`
+                      )
+                    );
+                  try {
+                    const manifest3 = JSON.parse(result2);
+                    resolve2(manifest3);
+                  } catch (parseError) {
+                    const manifestPath = makePathsRelative(
+                      compiler.context,
+                      manifestParameter,
+                      compiler.root
+                    );
+                    this.errors.set(
+                      params,
+                      new DllManifestError(
+                        manifestPath,
+                        parseError.message
+                      )
+                    );
+                  }
+                }
+              );
+            } else {
+              resolve2(manifest2);
+            }
+          } else {
+            resolve2(void 0);
+          }
+        });
+        if (!this.errors.has(params)) {
+          new DllReferenceAgencyPlugin({
+            ...this.options,
+            type: this.options.type || "require",
+            extensions: this.options.extensions || [
+              "",
+              ".js",
+              ".json",
+              ".wasm"
+            ],
+            manifest
+          }).apply(compiler);
+        }
+      }
+    );
+    compiler.hooks.compilation.tap(
+      _DllReferencePlugin.name,
+      (compilation, params) => {
+        if ("manifest" in this.options && typeof this.options.manifest === "string") {
+          const error = this.errors.get(params);
+          if (error) {
+            compilation.errors.push(error);
+          }
+          compilation.fileDependencies.add(this.options.manifest);
+        }
+      }
+    );
+  }
+};
+var DllManifestError = class extends WebpackError_default {
+  constructor(filename2, message) {
+    super();
+    this.name = "DllManifestError";
+    this.message = `Dll manifest ${filename2}
+${message}`;
+  }
+};
+
 // src/lib/EnvironmentPlugin.ts
 var EnvironmentPlugin = class {
   constructor(...keys) {
@@ -18453,9 +19263,9 @@ var NodeTemplatePlugin = class {
 };
 
 // src/container/ModuleFederationRuntimePlugin.ts
-var import_binding76 = require("@rspack/binding");
+var import_binding79 = require("@rspack/binding");
 var ModuleFederationRuntimePlugin = create2(
-  import_binding76.BuiltinPluginName.ModuleFederationRuntimePlugin,
+  import_binding79.BuiltinPluginName.ModuleFederationRuntimePlugin,
   () => {
   }
 );
@@ -18651,10 +19461,10 @@ function getDefaultEntryRuntime(paths, options, compiler) {
 }
 
 // src/sharing/ConsumeSharedPlugin.ts
-var import_binding78 = require("@rspack/binding");
+var import_binding81 = require("@rspack/binding");
 
 // src/sharing/ShareRuntimePlugin.ts
-var import_binding77 = require("@rspack/binding");
+var import_binding80 = require("@rspack/binding");
 var compilerSet = /* @__PURE__ */ new WeakSet();
 function isSingleton(compiler) {
   return compilerSet.has(compiler);
@@ -18666,7 +19476,7 @@ var ShareRuntimePlugin = class extends RspackBuiltinPlugin {
   constructor(enhanced = false) {
     super();
     this.enhanced = enhanced;
-    this.name = import_binding77.BuiltinPluginName.ShareRuntimePlugin;
+    this.name = import_binding80.BuiltinPluginName.ShareRuntimePlugin;
   }
   raw(compiler) {
     if (isSingleton(compiler)) return;
@@ -18685,7 +19495,7 @@ function isRequiredVersion(str) {
 var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding78.BuiltinPluginName.ConsumeSharedPlugin;
+    this.name = import_binding81.BuiltinPluginName.ConsumeSharedPlugin;
     this._options = {
       consumes: parseOptions(
         options.consumes,
@@ -18748,11 +19558,11 @@ var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/sharing/ProvideSharedPlugin.ts
-var import_binding79 = require("@rspack/binding");
+var import_binding82 = require("@rspack/binding");
 var ProvideSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding79.BuiltinPluginName.ProvideSharedPlugin;
+    this.name = import_binding82.BuiltinPluginName.ProvideSharedPlugin;
     this._provides = parseOptions(
       options.provides,
       (item) => {
@@ -18857,11 +19667,11 @@ var SharePlugin = class {
 };
 
 // src/container/ContainerPlugin.ts
-var import_binding80 = require("@rspack/binding");
+var import_binding83 = require("@rspack/binding");
 var ContainerPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding80.BuiltinPluginName.ContainerPlugin;
+    this.name = import_binding83.BuiltinPluginName.ContainerPlugin;
     this._options = {
       name: options.name,
       shareScope: options.shareScope || "default",
@@ -18905,11 +19715,11 @@ var ContainerPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/container/ContainerReferencePlugin.ts
-var import_binding81 = require("@rspack/binding");
+var import_binding84 = require("@rspack/binding");
 var ContainerReferencePlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding81.BuiltinPluginName.ContainerReferencePlugin;
+    this.name = import_binding84.BuiltinPluginName.ContainerReferencePlugin;
     this._options = {
       remoteType: options.remoteType,
       remotes: parseOptions(
@@ -18994,7 +19804,7 @@ var ModuleFederationPluginV1 = class {
 };
 
 // src/exports.ts
-var import_binding82 = require("@rspack/binding");
+var import_binding85 = require("@rspack/binding");
 var rspackVersion = import_package.version;
 var version = import_package.webpackVersion;
 var WebpackError2 = Error;
@@ -19040,8 +19850,8 @@ var sharing = {
 };
 var experiments2 = {
   globalTrace: {
-    register: import_binding82.registerGlobalTrace,
-    cleanup: import_binding82.cleanupGlobalTrace
+    register: import_binding85.registerGlobalTrace,
+    cleanup: import_binding85.cleanupGlobalTrace
   },
   RemoveDuplicateModulesPlugin
 };
@@ -19162,6 +19972,8 @@ module.exports = rspack;
   CopyRspackPlugin,
   CssExtractRspackPlugin,
   DefinePlugin,
+  DllPlugin,
+  DllReferencePlugin,
   DynamicEntryPlugin,
   EntryOptionPlugin,
   EntryPlugin,