@rspack/core 1.1.0-beta.0 → 1.1.1

package/dist/index.js

@@ -143,9 +143,9 @@ var require_lib = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/enhanced-resolve@5.12.0/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js
+// ../../node_modules/.pnpm/enhanced-resolve@5.17.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js
 var require_CachedInputFileSystem = __commonJS({
-  "../../node_modules/.pnpm/enhanced-resolve@5.12.0/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js"(exports2, module2) {
+  "../../node_modules/.pnpm/enhanced-resolve@5.17.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js"(exports2, module2) {
     "use strict";
     var nextTick = require("process").nextTick;
     var dirname4 = (path10) => {
@@ -177,46 +177,81 @@ var require_CachedInputFileSystem = __commonJS({
     };
     var OperationMergerBackend = class {
       /**
-       * @param {any} provider async method
-       * @param {any} syncProvider sync method
-       * @param {any} providerContext call context for the provider methods
+       * @param {Function | undefined} provider async method in filesystem
+       * @param {Function | undefined} syncProvider sync method in filesystem
+       * @param {BaseFileSystem} providerContext call context for the provider methods
        */
       constructor(provider, syncProvider, providerContext) {
         this._provider = provider;
         this._syncProvider = syncProvider;
         this._providerContext = providerContext;
         this._activeAsyncOperations = /* @__PURE__ */ new Map();
-        this.provide = this._provider ? (path10, options, callback) => {
-          if (typeof options === "function") {
-            callback = options;
-            options = void 0;
-          }
-          if (options) {
-            return this._provider.call(
-              this._providerContext,
+        this.provide = this._provider ? (
+          /**
+           * @param {PathLike | PathOrFileDescriptor} path path
+           * @param {object | FileSystemCallback<any> | undefined} options options
+           * @param {FileSystemCallback<any>=} callback callback
+           * @returns {any} result
+           */
+          (path10, options, callback) => {
+            if (typeof options === "function") {
+              callback = /** @type {FileSystemCallback<any>} */
+              options;
+              options = void 0;
+            }
+            if (typeof path10 !== "string" && !Buffer.isBuffer(path10) && !(path10 instanceof URL) && typeof path10 !== "number") {
+              callback(
+                new TypeError("path must be a string, Buffer, URL or number")
+              );
+              return;
+            }
+            if (options) {
+              return (
+                /** @type {Function} */
+                this._provider.call(
+                  this._providerContext,
+                  path10,
+                  options,
+                  callback
+                )
+              );
+            }
+            let callbacks = this._activeAsyncOperations.get(path10);
+            if (callbacks) {
+              callbacks.push(callback);
+              return;
+            }
+            this._activeAsyncOperations.set(path10, callbacks = [callback]);
+            provider(
               path10,
-              options,
-              callback
+              /**
+               * @param {Error} err error
+               * @param {any} result result
+               */
+              (err, result2) => {
+                this._activeAsyncOperations.delete(path10);
+                runCallbacks(callbacks, err, result2);
+              }
             );
           }
-          if (typeof path10 !== "string") {
-            callback(new TypeError("path must be a string"));
-            return;
-          }
-          let callbacks = this._activeAsyncOperations.get(path10);
-          if (callbacks) {
-            callbacks.push(callback);
-            return;
+        ) : null;
+        this.provideSync = this._syncProvider ? (
+          /**
+           * @param {PathLike | PathOrFileDescriptor} path path
+           * @param {object=} options options
+           * @returns {any} result
+           */
+          (path10, options) => {
+            return (
+              /** @type {Function} */
+              this._syncProvider.call(
+                this._providerContext,
+                path10,
+                options
+              )
+            );
           }
-          this._activeAsyncOperations.set(path10, callbacks = [callback]);
-          provider(path10, (err, result2) => {
-            this._activeAsyncOperations.delete(path10);
-            runCallbacks(callbacks, err, result2);
-          });
-        } : null;
-        this.provideSync = this._syncProvider ? (path10, options) => {
-          return this._syncProvider.call(this._providerContext, path10, options);
-        } : null;
+        ) : null;
       }
       purge() {
       }
@@ -229,9 +264,9 @@ var require_CachedInputFileSystem = __commonJS({
     var CacheBackend = class {
       /**
        * @param {number} duration max cache duration of items
-       * @param {any} provider async method
-       * @param {any} syncProvider sync method
-       * @param {any} providerContext call context for the provider methods
+       * @param {function | undefined} provider async method
+       * @param {function | undefined} syncProvider sync method
+       * @param {BaseFileSystem} providerContext call context for the provider methods
        */
       constructor(duration, provider, syncProvider, providerContext) {
         this._duration = duration;
@@ -251,75 +286,132 @@ var require_CachedInputFileSystem = __commonJS({
         this.provide = provider ? this.provide.bind(this) : null;
         this.provideSync = syncProvider ? this.provideSync.bind(this) : null;
       }
+      /**
+       * @param {PathLike | PathOrFileDescriptor} path path
+       * @param {any} options options
+       * @param {FileSystemCallback<any>} callback callback
+       * @returns {void}
+       */
       provide(path10, options, callback) {
         if (typeof options === "function") {
           callback = options;
           options = void 0;
         }
-        if (typeof path10 !== "string") {
-          callback(new TypeError("path must be a string"));
+        if (typeof path10 !== "string" && !Buffer.isBuffer(path10) && !(path10 instanceof URL) && typeof path10 !== "number") {
+          callback(new TypeError("path must be a string, Buffer, URL or number"));
           return;
         }
+        const strPath = typeof path10 !== "string" ? path10.toString() : path10;
         if (options) {
-          return this._provider.call(
-            this._providerContext,
-            path10,
-            options,
-            callback
+          return (
+            /** @type {Function} */
+            this._provider.call(
+              this._providerContext,
+              path10,
+              options,
+              callback
+            )
           );
         }
         if (this._mode === STORAGE_MODE_SYNC) {
           this._enterAsyncMode();
         }
-        let cacheEntry = this._data.get(path10);
+        let cacheEntry = this._data.get(strPath);
         if (cacheEntry !== void 0) {
           if (cacheEntry.err) return nextTick(callback, cacheEntry.err);
           return nextTick(callback, null, cacheEntry.result);
         }
-        let callbacks = this._activeAsyncOperations.get(path10);
+        let callbacks = this._activeAsyncOperations.get(strPath);
         if (callbacks !== void 0) {
           callbacks.push(callback);
           return;
         }
-        this._activeAsyncOperations.set(path10, callbacks = [callback]);
-        this._provider.call(this._providerContext, path10, (err, result2) => {
-          this._activeAsyncOperations.delete(path10);
-          this._storeResult(path10, err, result2);
-          this._enterAsyncMode();
-          runCallbacks(callbacks, err, result2);
-        });
+        this._activeAsyncOperations.set(strPath, callbacks = [callback]);
+        this._provider.call(
+          this._providerContext,
+          path10,
+          /**
+           * @param {Error | null} err error
+           * @param {any} [result] result
+           */
+          (err, result2) => {
+            this._activeAsyncOperations.delete(strPath);
+            this._storeResult(strPath, err, result2);
+            this._enterAsyncMode();
+            runCallbacks(
+              /** @type {FileSystemCallback<any>[]} */
+              callbacks,
+              err,
+              result2
+            );
+          }
+        );
       }
+      /**
+       * @param {PathLike | PathOrFileDescriptor} path path
+       * @param {any} options options
+       * @returns {any} result
+       */
       provideSync(path10, options) {
-        if (typeof path10 !== "string") {
+        if (typeof path10 !== "string" && !Buffer.isBuffer(path10) && !(path10 instanceof URL) && typeof path10 !== "number") {
           throw new TypeError("path must be a string");
         }
+        const strPath = typeof path10 !== "string" ? path10.toString() : path10;
         if (options) {
-          return this._syncProvider.call(this._providerContext, path10, options);
+          return (
+            /** @type {Function} */
+            this._syncProvider.call(
+              this._providerContext,
+              path10,
+              options
+            )
+          );
         }
         if (this._mode === STORAGE_MODE_SYNC) {
           this._runDecays();
         }
-        let cacheEntry = this._data.get(path10);
+        let cacheEntry = this._data.get(strPath);
         if (cacheEntry !== void 0) {
           if (cacheEntry.err) throw cacheEntry.err;
           return cacheEntry.result;
         }
-        const callbacks = this._activeAsyncOperations.get(path10);
-        this._activeAsyncOperations.delete(path10);
+        const callbacks = this._activeAsyncOperations.get(strPath);
+        this._activeAsyncOperations.delete(strPath);
         let result2;
         try {
-          result2 = this._syncProvider.call(this._providerContext, path10);
+          result2 = /** @type {Function} */
+          this._syncProvider.call(
+            this._providerContext,
+            path10
+          );
         } catch (err) {
-          this._storeResult(path10, err, void 0);
+          this._storeResult(
+            strPath,
+            /** @type {Error} */
+            err,
+            void 0
+          );
           this._enterSyncModeWhenIdle();
-          if (callbacks) runCallbacks(callbacks, err, void 0);
+          if (callbacks) {
+            runCallbacks(
+              callbacks,
+              /** @type {Error} */
+              err,
+              void 0
+            );
+          }
           throw err;
         }
-        this._storeResult(path10, void 0, result2);
+        this._storeResult(strPath, null, result2);
         this._enterSyncModeWhenIdle();
-        if (callbacks) runCallbacks(callbacks, void 0, result2);
+        if (callbacks) {
+          runCallbacks(callbacks, null, result2);
+        }
         return result2;
       }
+      /**
+       * @param {string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set<string | URL | Buffer | number>} [what] what to purge
+       */
       purge(what) {
         if (!what) {
           if (this._mode !== STORAGE_MODE_IDLE) {
@@ -329,9 +421,10 @@ var require_CachedInputFileSystem = __commonJS({
             }
             this._enterIdleMode();
           }
-        } else if (typeof what === "string") {
+        } else if (typeof what === "string" || Buffer.isBuffer(what) || what instanceof URL || typeof what === "number") {
+          const strWhat = typeof what !== "string" ? what.toString() : what;
           for (let [key, data] of this._data) {
-            if (key.startsWith(what)) {
+            if (key.startsWith(strWhat)) {
               this._data.delete(key);
               data.level.delete(key);
             }
@@ -342,7 +435,8 @@ var require_CachedInputFileSystem = __commonJS({
         } else {
           for (let [key, data] of this._data) {
             for (const item of what) {
-              if (key.startsWith(item)) {
+              const strItem = typeof item !== "string" ? item.toString() : item;
+              if (key.startsWith(strItem)) {
                 this._data.delete(key);
                 data.level.delete(key);
                 break;
@@ -354,19 +448,29 @@ var require_CachedInputFileSystem = __commonJS({
           }
         }
       }
+      /**
+       * @param {string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set<string | URL | Buffer | number>} [what] what to purge
+       */
       purgeParent(what) {
         if (!what) {
           this.purge();
-        } else if (typeof what === "string") {
-          this.purge(dirname4(what));
+        } else if (typeof what === "string" || Buffer.isBuffer(what) || what instanceof URL || typeof what === "number") {
+          const strWhat = typeof what !== "string" ? what.toString() : what;
+          this.purge(dirname4(strWhat));
         } else {
           const set = /* @__PURE__ */ new Set();
           for (const item of what) {
-            set.add(dirname4(item));
+            const strItem = typeof item !== "string" ? item.toString() : item;
+            set.add(dirname4(strItem));
           }
           this.purge(set);
         }
       }
+      /**
+       * @param {string} path path
+       * @param {Error | null} err error
+       * @param {any} result result
+       */
       _storeResult(path10, err, result2) {
         if (this._data.has(path10)) return;
         const level = this._levels[this._currentLevel];
@@ -406,7 +510,11 @@ var require_CachedInputFileSystem = __commonJS({
             break;
           case STORAGE_MODE_SYNC:
             this._runDecays();
-            if (this._mode === STORAGE_MODE_IDLE) return;
+            if (
+              /** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC}*/
+              this._mode === STORAGE_MODE_IDLE
+            )
+              return;
             timeout = Math.max(
               0,
               /** @type {number} */
@@ -441,6 +549,10 @@ var require_CachedInputFileSystem = __commonJS({
       return new OperationMergerBackend(provider, syncProvider, providerContext);
     };
     module2.exports = class CachedInputFileSystem {
+      /**
+       * @param {BaseFileSystem} fileSystem file system
+       * @param {number} duration duration in ms files are cached
+       */
       constructor(fileSystem, duration) {
         this.fileSystem = fileSystem;
         this._lstatBackend = createBackend(
@@ -493,7 +605,12 @@ var require_CachedInputFileSystem = __commonJS({
         readFileSync2;
         this._readJsonBackend = createBackend(
           duration,
-          this.fileSystem.readJson || this.readFile && ((path10, callback) => {
+          // prettier-ignore
+          this.fileSystem.readJson || this.readFile && /**
+           * @param {string} path path
+           * @param {FileSystemCallback<any>} callback
+           */
+          ((path10, callback) => {
             this.readFile(path10, (err, buffer) => {
               if (err) return callback(err);
               if (!buffer || buffer.length === 0)
@@ -502,12 +619,20 @@ var require_CachedInputFileSystem = __commonJS({
               try {
                 data = JSON.parse(buffer.toString("utf-8"));
               } catch (e) {
-                return callback(e);
+                return callback(
+                  /** @type {Error} */
+                  e
+                );
               }
               callback(null, data);
             });
           }),
-          this.fileSystem.readJsonSync || this.readFileSync && ((path10) => {
+          // prettier-ignore
+          this.fileSystem.readJsonSync || this.readFileSync && /**
+           * @param {string} path path
+           * @returns {any} result
+           */
+          ((path10) => {
             const buffer = this.readFileSync(path10);
             const data = JSON.parse(buffer.toString("utf-8"));
             return data;
@@ -532,7 +657,22 @@ var require_CachedInputFileSystem = __commonJS({
         const readlinkSync = this._readlinkBackend.provideSync;
         this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */
         readlinkSync;
+        this._realpathBackend = createBackend(
+          duration,
+          this.fileSystem.realpath,
+          this.fileSystem.realpathSync,
+          this.fileSystem
+        );
+        const realpath = this._realpathBackend.provide;
+        this.realpath = /** @type {FileSystem["realpath"]} */
+        realpath;
+        const realpathSync = this._realpathBackend.provideSync;
+        this.realpathSync = /** @type {SyncFileSystem["realpathSync"]} */
+        realpathSync;
       }
+      /**
+       * @param {string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set<string | URL | Buffer | number>} [what] what to purge
+       */
       purge(what) {
         this._statBackend.purge(what);
         this._lstatBackend.purge(what);
@@ -540,6 +680,7 @@ var require_CachedInputFileSystem = __commonJS({
         this._readFileBackend.purge(what);
         this._readlinkBackend.purge(what);
         this._readJsonBackend.purge(what);
+        this._realpathBackend.purge(what);
       }
     };
   }
@@ -555,6 +696,8 @@ __export(src_exports, {
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
+  DllPlugin: () => DllPlugin,
+  DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
@@ -617,6 +760,8 @@ __export(exports_exports, {
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
+  DllPlugin: () => DllPlugin,
+  DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
@@ -996,14 +1141,28 @@ var Dependency = class _Dependency {
 // src/DependenciesBlock.ts
 var DependenciesBlock = class _DependenciesBlock {
   #binding;
-  constructor(binding3) {
-    this.#binding = binding3;
+  static __from_binding(binding3) {
+    return new _DependenciesBlock(binding3);
   }
-  get dependencies() {
-    return this.#binding.dependencies.map((d) => Dependency.__from_binding(d));
+  static __to_binding(block) {
+    return block.#binding;
   }
-  get blocks() {
-    return this.#binding.blocks.map((b) => new _DependenciesBlock(b));
+  constructor(binding3) {
+    this.#binding = binding3;
+    Object.defineProperties(this, {
+      dependencies: {
+        enumerable: true,
+        get() {
+          return binding3.dependencies.map((d) => Dependency.__from_binding(d));
+        }
+      },
+      blocks: {
+        enumerable: true,
+        get() {
+          return binding3.blocks.map((b) => _DependenciesBlock.__from_binding(b));
+        }
+      }
+    });
   }
 };
 
@@ -1083,21 +1242,10 @@ var ContextModuleFactoryBeforeResolveData = class _ContextModuleFactoryBeforeRes
       regExp: {
         enumerable: true,
         get() {
-          if (!binding3.regExp) {
-            return void 0;
-          }
-          const { source, flags } = binding3.regExp;
-          return new RegExp(source, flags);
+          return binding3.regExp;
         },
         set(val) {
-          if (!val) {
-            binding3.regExp = void 0;
-            return;
-          }
-          binding3.regExp = {
-            source: val.source,
-            flags: val.flags
-          };
+          binding3.regExp = val;
         }
       },
       recursive: {
@@ -1153,21 +1301,10 @@ var ContextModuleFactoryAfterResolveData = class _ContextModuleFactoryAfterResol
       regExp: {
         enumerable: true,
         get() {
-          if (!binding3.regExp) {
-            return void 0;
-          }
-          const { source, flags } = binding3.regExp;
-          return new RegExp(source, flags);
+          return binding3.regExp;
         },
         set(val) {
-          if (!val) {
-            binding3.regExp = void 0;
-            return;
-          }
-          binding3.regExp = {
-            source: val.source,
-            flags: val.flags
-          };
+          binding3.regExp = val;
         }
       },
       recursive: {
@@ -1190,46 +1327,128 @@ var ContextModuleFactoryAfterResolveData = class _ContextModuleFactoryAfterResol
     });
   }
 };
+var MODULE_MAPPINGS = /* @__PURE__ */ new WeakMap();
 var Module = class _Module {
   #inner;
-  #originalSource;
-  static __from_binding(module2, compilation) {
-    return new _Module(module2, compilation);
+  static __from_binding(binding3, compilation) {
+    let module2 = MODULE_MAPPINGS.get(binding3);
+    if (module2) {
+      return module2;
+    }
+    module2 = new _Module(binding3, compilation);
+    MODULE_MAPPINGS.set(binding3, module2);
+    return module2;
   }
   constructor(module2, compilation) {
     this.#inner = module2;
-    this.type = module2.type;
-    this.layer = module2.layer ?? null;
-    this.context = module2.context;
-    this.resource = module2.resource;
-    this.request = module2.request;
-    this.userRequest = module2.userRequest;
-    this.rawRequest = module2.rawRequest;
-    this.factoryMeta = module2.factoryMeta;
-    const customModule = compilation == null ? void 0 : compilation.__internal__getCustomModule(
-      module2.moduleIdentifier
-    );
-    this.buildInfo = (customModule == null ? void 0 : customModule.buildInfo) || {};
-    this.buildMeta = (customModule == null ? void 0 : customModule.buildMeta) || {};
     Object.defineProperties(this, {
+      type: {
+        enumerable: true,
+        get() {
+          return module2.type || null;
+        }
+      },
+      layer: {
+        enumerable: true,
+        get() {
+          return module2.layer;
+        }
+      },
+      context: {
+        enumerable: true,
+        get() {
+          return module2.context;
+        }
+      },
+      resource: {
+        enumerable: true,
+        get() {
+          return module2.resource;
+        }
+      },
+      request: {
+        enumerable: true,
+        get() {
+          return module2.request;
+        }
+      },
+      userRequest: {
+        enumerable: true,
+        get() {
+          return module2.userRequest;
+        },
+        set(val) {
+          module2.userRequest = val;
+        }
+      },
+      rawRequest: {
+        enumerable: true,
+        get() {
+          return module2.rawRequest;
+        }
+      },
+      factoryMeta: {
+        enumerable: true,
+        get() {
+          return module2.factoryMeta;
+        }
+      },
       modules: {
         enumerable: true,
         get() {
-          if (module2 instanceof import_binding4.ModuleDto) {
+          if (module2 instanceof import_binding4.JsModule) {
             return module2.modules ? module2.modules.map((m) => _Module.__from_binding(m)) : void 0;
           }
           return void 0;
         }
+      },
+      buildInfo: {
+        enumerable: true,
+        get() {
+          const customModule = compilation == null ? void 0 : compilation.__internal__getCustomModule(
+            module2.moduleIdentifier
+          );
+          return (customModule == null ? void 0 : customModule.buildInfo) || {};
+        }
+      },
+      buildMeta: {
+        enumerable: true,
+        get() {
+          const customModule = compilation == null ? void 0 : compilation.__internal__getCustomModule(
+            module2.moduleIdentifier
+          );
+          return (customModule == null ? void 0 : customModule.buildMeta) || {};
+        }
+      },
+      blocks: {
+        enumerable: true,
+        get() {
+          if ("blocks" in module2) {
+            return module2.blocks.map((b) => DependenciesBlock.__from_binding(b));
+          }
+          return [];
+        }
+      },
+      dependencies: {
+        enumerable: true,
+        get() {
+          if ("dependencies" in module2) {
+            return module2.dependencies.map((d) => Dependency.__from_binding(d));
+          }
+          return [];
+        }
+      },
+      useSourceMap: {
+        enumerable: true,
+        get() {
+          return module2.useSourceMap;
+        }
       }
     });
   }
   originalSource() {
-    if (this.#originalSource) return this.#originalSource;
     if (this.#inner.originalSource) {
-      this.#originalSource = JsSource.__from_binding(
-        this.#inner.originalSource
-      );
-      return this.#originalSource;
+      return JsSource.__from_binding(this.#inner.originalSource);
     }
     return null;
   }
@@ -1242,12 +1461,6 @@ var Module = class _Module {
     }
     return null;
   }
-  get blocks() {
-    if ("blocks" in this.#inner) {
-      return this.#inner.blocks.map((b) => new DependenciesBlock(b));
-    }
-    return [];
-  }
   size(type) {
     if ("size" in this.#inner) {
       return this.#inner.size(type);
@@ -1448,7 +1661,8 @@ var RuntimeModule = class {
       name: module2.name,
       stage: module2.stage,
       generator: module2.generate.bind(module2),
-      cacheable: !(module2.fullHash || module2.dependentHash),
+      fullHash: module2.fullHash,
+      dependentHash: module2.dependentHash,
       isolate: module2.shouldIsolate()
     };
   }
@@ -5977,7 +6191,13 @@ async function runLoaders(compiler, context2) {
               if (res.cacheable === false) {
                 this.cacheable(false);
               }
-              resolve2(compiler.__internal__getModuleExecutionResult(res.id));
+              if (res.error) {
+                reject(new Error(err));
+              } else {
+                resolve2(
+                  compiler.__internal__getModuleExecutionResult(res.id)
+                );
+              }
             }
           }
         );
@@ -6009,10 +6229,14 @@ async function runLoaders(compiler, context2) {
           if (res.cacheable === false) {
             this.cacheable(false);
           }
-          callback(
-            void 0,
-            compiler.__internal__getModuleExecutionResult(res.id)
-          );
+          if (res.error) {
+            callback(new Error(err), void 0);
+          } else {
+            callback(
+              void 0,
+              compiler.__internal__getModuleExecutionResult(res.id)
+            );
+          }
         }
       }
     );
@@ -6272,65 +6496,78 @@ async function runLoaders(compiler, context2) {
     enumerable: true,
     get: () => context2.__internal__parseMeta
   });
-  switch (loaderState) {
-    case import_binding23.JsLoaderState.Pitching: {
-      while (loaderContext.loaderIndex < loaderContext.loaders.length) {
-        const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
-        if (currentLoaderObject.shouldYield()) break;
-        if (currentLoaderObject.pitchExecuted) {
-          loaderContext.loaderIndex += 1;
-          continue;
-        }
-        await loadLoaderAsync(currentLoaderObject);
-        const fn2 = currentLoaderObject.pitch;
-        currentLoaderObject.pitchExecuted = true;
-        if (!fn2) continue;
-        const args = await runSyncOrAsync(fn2, loaderContext, [
-          loaderContext.remainingRequest,
-          loaderContext.previousRequest,
-          currentLoaderObject.data
-        ]) || [];
-        const hasArg = args.some((value) => value !== void 0);
-        if (hasArg) {
-          const [content, sourceMap, additionalData] = args;
-          context2.content = isNil(content) ? null : toBuffer(content);
-          context2.sourceMap = serializeObject(sourceMap);
-          context2.additionalData = additionalData;
-          break;
+  try {
+    switch (loaderState) {
+      case import_binding23.JsLoaderState.Pitching: {
+        while (loaderContext.loaderIndex < loaderContext.loaders.length) {
+          const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+          if (currentLoaderObject.shouldYield()) break;
+          if (currentLoaderObject.pitchExecuted) {
+            loaderContext.loaderIndex += 1;
+            continue;
+          }
+          await loadLoaderAsync(currentLoaderObject);
+          const fn2 = currentLoaderObject.pitch;
+          currentLoaderObject.pitchExecuted = true;
+          if (!fn2) continue;
+          const args = await runSyncOrAsync(fn2, loaderContext, [
+            loaderContext.remainingRequest,
+            loaderContext.previousRequest,
+            currentLoaderObject.data
+          ]) || [];
+          const hasArg = args.some((value) => value !== void 0);
+          if (hasArg) {
+            const [content, sourceMap, additionalData] = args;
+            context2.content = isNil(content) ? null : toBuffer(content);
+            context2.sourceMap = serializeObject(sourceMap);
+            context2.additionalData = additionalData;
+            break;
+          }
         }
+        break;
       }
-      break;
-    }
-    case import_binding23.JsLoaderState.Normal: {
-      let content = context2.content;
-      let sourceMap = JsSourceMap.__from_binding(context2.sourceMap);
-      let additionalData = context2.additionalData;
-      while (loaderContext.loaderIndex >= 0) {
-        const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
-        if (currentLoaderObject.shouldYield()) break;
-        if (currentLoaderObject.normalExecuted) {
-          loaderContext.loaderIndex--;
-          continue;
+      case import_binding23.JsLoaderState.Normal: {
+        let content = context2.content;
+        let sourceMap = JsSourceMap.__from_binding(context2.sourceMap);
+        let additionalData = context2.additionalData;
+        while (loaderContext.loaderIndex >= 0) {
+          const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+          if (currentLoaderObject.shouldYield()) break;
+          if (currentLoaderObject.normalExecuted) {
+            loaderContext.loaderIndex--;
+            continue;
+          }
+          await loadLoaderAsync(currentLoaderObject);
+          const fn2 = currentLoaderObject.normal;
+          currentLoaderObject.normalExecuted = true;
+          if (!fn2) continue;
+          const args = [content, sourceMap, additionalData];
+          convertArgs(args, !!currentLoaderObject.raw);
+          [content, sourceMap, additionalData] = await runSyncOrAsync(fn2, loaderContext, args) || [];
         }
-        await loadLoaderAsync(currentLoaderObject);
-        const fn2 = currentLoaderObject.normal;
-        currentLoaderObject.normalExecuted = true;
-        if (!fn2) continue;
-        const args = [content, sourceMap, additionalData];
-        convertArgs(args, !!currentLoaderObject.raw);
-        [content, sourceMap, additionalData] = await runSyncOrAsync(fn2, loaderContext, args) || [];
+        context2.content = isNil(content) ? null : toBuffer(content);
+        context2.sourceMap = JsSourceMap.__to_binding(sourceMap);
+        context2.additionalData = additionalData;
+        break;
       }
-      context2.content = isNil(content) ? null : toBuffer(content);
-      context2.sourceMap = JsSourceMap.__to_binding(sourceMap);
-      context2.additionalData = additionalData;
-      break;
+      default:
+        throw new Error(`Unexpected loader runner state: ${loaderState}`);
     }
-    default:
-      throw new Error(`Unexpected loader runner state: ${loaderState}`);
+    context2.loaderItems = loaderContext.loaders.map(
+      (item) => LoaderObject.__to_binding(item)
+    );
+  } catch (e) {
+    const error = e;
+    context2.__internal__error = typeof e === "string" ? {
+      name: "ModuleBuildError",
+      message: e
+    } : {
+      name: "ModuleBuildError",
+      message: error.message,
+      stack: typeof error.stack === "string" ? error.stack : void 0,
+      hideStack: "hideStack" in error ? error.hideStack === true || error.hideStack === "true" : void 0
+    };
   }
-  context2.loaderItems = loaderContext.loaders.map(
-    (item) => LoaderObject.__to_binding(item)
-  );
   return context2;
 }
 function utf8BufferToString(buf) {
@@ -6755,7 +6992,7 @@ var getRawModuleRule = (rule, path10, options, upperType) => {
     parser: rule.parser ? getRawParserOptions(rule.parser, rule.type ?? upperType) : void 0,
     generator: rule.generator ? getRawGeneratorOptions(rule.generator, rule.type ?? upperType) : void 0,
     resolve: rule.resolve ? getRawResolve(rule.resolve) : void 0,
-    oneOf: rule.oneOf ? rule.oneOf.map(
+    oneOf: rule.oneOf ? rule.oneOf.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
         `${path10}.oneOf[${index}]`,
@@ -6763,7 +7000,7 @@ var getRawModuleRule = (rule, path10, options, upperType) => {
         rule2.type ?? upperType
       )
     ) : void 0,
-    rules: rule.rules ? rule.rules.map(
+    rules: rule.rules ? rule.rules.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
         `${path10}.rules[${index}]`,
@@ -6809,10 +7046,7 @@ function getRawRuleSetCondition(condition) {
   if (condition instanceof RegExp) {
     return {
       type: import_binding24.RawRuleSetConditionType.regexp,
-      regexp: {
-        source: condition.source,
-        flags: condition.flags
-      }
+      regexp: condition
     };
   }
   if (typeof condition === "function") {
@@ -8206,7 +8440,7 @@ var applyRspackOptionsDefaults = (options) => {
   D(options, "profile", false);
   D(options, "bail", false);
   F(options, "cache", () => development);
-  applyExperimentsDefaults(options.experiments);
+  applyExperimentsDefaults(options.experiments, { production });
   applySnapshotDefaults(options.snapshot, { production });
   applyModuleDefaults(options.module, {
     asyncWebAssembly: options.experiments.asyncWebAssembly,
@@ -8282,24 +8516,24 @@ var applyInfrastructureLoggingDefaults = (infrastructureLogging2) => {
   D(infrastructureLogging2, "colors", tty);
   D(infrastructureLogging2, "appendOnly", !tty);
 };
-var applyExperimentsDefaults = (experiments3) => {
+var applyExperimentsDefaults = (experiments3, { production }) => {
   D(experiments3, "futureDefaults", false);
   D(experiments3, "lazyCompilation", false);
   D(experiments3, "asyncWebAssembly", experiments3.futureDefaults);
   D(experiments3, "css", experiments3.futureDefaults ? true : void 0);
   D(experiments3, "layers", false);
   D(experiments3, "topLevelAwait", true);
-  D(experiments3, "incremental", {});
+  D(experiments3, "incremental", !production ? {} : false);
   if (typeof experiments3.incremental === "object") {
     D(experiments3.incremental, "make", true);
-    D(experiments3.incremental, "emitAssets", true);
     D(experiments3.incremental, "inferAsyncModules", false);
     D(experiments3.incremental, "providedExports", false);
     D(experiments3.incremental, "dependenciesDiagnostics", false);
+    D(experiments3.incremental, "buildChunkGraph", false);
     D(experiments3.incremental, "modulesHashes", false);
     D(experiments3.incremental, "modulesCodegen", false);
     D(experiments3.incremental, "modulesRuntimeRequirements", false);
-    D(experiments3.incremental, "buildChunkGraph", false);
+    D(experiments3.incremental, "emitAssets", true);
   }
   D(experiments3, "rspackFuture", {});
 };
@@ -9360,55 +9594,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",
@@ -9427,9 +9810,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(),
@@ -9438,12 +9821,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(),
@@ -9457,84 +9840,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(),
@@ -9543,7 +9926,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(),
@@ -9570,7 +9953,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(),
@@ -9584,60 +9967,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()
 });
@@ -9645,9 +10028,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(),
@@ -9659,67 +10042,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.array()).optional(),
-  rules: import_zod.z.lazy(() => ruleSetRule.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(),
@@ -9737,7 +10120,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(),
@@ -9747,63 +10130,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(),
@@ -9811,25 +10194,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",
@@ -9843,66 +10226,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",
@@ -9926,57 +10309,94 @@ var externalsType = import_zod.z.enum([
   "script",
   "node-commonjs"
 ]);
-var externalItemValue = import_zod.z.string().or(import_zod.z.boolean()).or(import_zod.z.string().array().min(1)).or(
-  import_zod.z.record(import_zod.z.string().or(import_zod.z.string().array()))
-);
-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",
@@ -10004,18 +10424,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",
@@ -10025,244 +10445,244 @@ 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 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(),
+  emitAssets: import_zod2.z.boolean().optional(),
+  inferAsyncModules: import_zod2.z.boolean().optional(),
+  providedExports: import_zod2.z.boolean().optional(),
+  dependenciesDiagnostics: import_zod2.z.boolean().optional(),
+  modulesHashes: import_zod2.z.boolean().optional(),
+  modulesCodegen: import_zod2.z.boolean().optional(),
+  modulesRuntimeRequirements: import_zod2.z.boolean().optional(),
+  buildChunkGraph: 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({
+  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(),
@@ -10523,16 +10943,44 @@ var FlagDependencyExportsPlugin = create2(
 
 // src/builtin-plugin/FlagDependencyUsagePlugin.ts
 var import_binding37 = require("@rspack/binding");
-var FlagDependencyUsagePlugin = create2(
-  import_binding37.BuiltinPluginName.FlagDependencyUsagePlugin,
-  (global) => global,
-  "compilation"
-);
-
-// src/builtin-plugin/HotModuleReplacementPlugin.ts
-var import_binding38 = require("@rspack/binding");
-var HotModuleReplacementPlugin = class extends RspackBuiltinPlugin {
-  constructor() {
+var FlagDependencyUsagePlugin = class extends RspackBuiltinPlugin {
+  constructor(global) {
+    super();
+    this.global = global;
+    this.name = import_binding37.BuiltinPluginName.FlagDependencyUsagePlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.FlagDependencyUsagePlugin"
+    );
+    if (incremental2.modulesHashes) {
+      incremental2.modulesHashes = false;
+      logger.warn(
+        "`optimization.usedExports` can't be used with `incremental.modulesHashes` as export usage is a global effect. `incremental.modulesHashes` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesCodegen) {
+      incremental2.modulesCodegen = false;
+      logger.warn(
+        "`optimization.usedExports` can't be used with `incremental.modulesCodegen` as export usage is a global effect. `incremental.modulesCodegen` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesRuntimeRequirements) {
+      incremental2.modulesRuntimeRequirements = false;
+      logger.warn(
+        "`optimization.usedExports` can't be used with `incremental.modulesRuntimeRequirements` as export usage is a global effect. `incremental.modulesRuntimeRequirements` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, this.global);
+  }
+};
+
+// src/builtin-plugin/HotModuleReplacementPlugin.ts
+var import_binding38 = require("@rspack/binding");
+var HotModuleReplacementPlugin = class extends RspackBuiltinPlugin {
+  constructor() {
     super(...arguments);
     this.name = import_binding38.BuiltinPluginName.HotModuleReplacementPlugin;
   }
@@ -10549,9 +10997,10 @@ var import_node_fs2 = __toESM(require("fs"));
 var import_node_path8 = __toESM(require("path"));
 var import_binding39 = 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.3.1_zod@3.23.8/node_modules/zod-validation-error/dist/index.mjs
+// ../../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);
 var zod = __toESM(require("../compiled/zod/index.js"), 1);
 function isZodErrorLike(err) {
   return err instanceof Error && err.name === "ZodError" && "issues" in err && Array.isArray(err.issues);
@@ -10577,22 +11026,8 @@ function getIssuesFromErrorOptions(options) {
   }
   return [];
 }
-var ISSUE_SEPARATOR = "; ";
-var MAX_ISSUES_IN_MESSAGE = 99;
-var PREFIX = "Validation error";
-var PREFIX_SEPARATOR = ": ";
-var UNION_SEPARATOR = ", or ";
-function prefixMessage(message, prefix, prefixSeparator) {
-  if (prefix !== null) {
-    if (message.length > 0) {
-      return [prefix, message].join(prefixSeparator);
-    }
-    return prefix;
-  }
-  if (message.length > 0) {
-    return message;
-  }
-  return PREFIX;
+function isNonEmptyArray(value) {
+  return value.length !== 0;
 }
 var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
 function joinPath(path10) {
@@ -10616,12 +11051,35 @@ function joinPath(path10) {
 function escapeQuotes(str) {
   return str.replace(/"/g, '\\"');
 }
-function isNonEmptyArray(value) {
-  return value.length !== 0;
+var ISSUE_SEPARATOR = "; ";
+var MAX_ISSUES_IN_MESSAGE = 99;
+var PREFIX = "Validation error";
+var PREFIX_SEPARATOR = ": ";
+var UNION_SEPARATOR = ", or ";
+function createMessageBuilder(props = {}) {
+  const {
+    issueSeparator = ISSUE_SEPARATOR,
+    unionSeparator = UNION_SEPARATOR,
+    prefixSeparator = PREFIX_SEPARATOR,
+    prefix = PREFIX,
+    includePath = true,
+    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE
+  } = props;
+  return (issues) => {
+    const message = issues.slice(0, maxIssuesInMessage).map(
+      (issue) => getMessageFromZodIssue({
+        issue,
+        issueSeparator,
+        unionSeparator,
+        includePath
+      })
+    ).join(issueSeparator);
+    return prefixMessage(message, prefix, prefixSeparator);
+  };
 }
 function getMessageFromZodIssue(props) {
   const { issue, issueSeparator, unionSeparator, includePath } = props;
-  if (issue.code === "invalid_union") {
+  if (issue.code === zod.ZodIssueCode.invalid_union) {
     return issue.unionErrors.reduce((acc, zodError) => {
       const newIssues = zodError.issues.map(
         (issue2) => getMessageFromZodIssue({
@@ -10637,7 +11095,7 @@ function getMessageFromZodIssue(props) {
       return acc;
     }, []).join(unionSeparator);
   }
-  if (issue.code === "invalid_arguments") {
+  if (issue.code === zod.ZodIssueCode.invalid_arguments) {
     return [
       issue.message,
       ...issue.argumentsError.issues.map(
@@ -10650,7 +11108,7 @@ function getMessageFromZodIssue(props) {
       )
     ].join(issueSeparator);
   }
-  if (issue.code === "invalid_return_type") {
+  if (issue.code === zod.ZodIssueCode.invalid_return_type) {
     return [
       issue.message,
       ...issue.returnTypeError.issues.map(
@@ -10674,6 +11132,18 @@ function getMessageFromZodIssue(props) {
   }
   return issue.message;
 }
+function prefixMessage(message, prefix, prefixSeparator) {
+  if (prefix !== null) {
+    if (message.length > 0) {
+      return [prefix, message].join(prefixSeparator);
+    }
+    return prefix;
+  }
+  if (message.length > 0) {
+    return message;
+  }
+  return PREFIX;
+}
 function fromZodError(zodError, options = {}) {
   if (!isZodErrorLike(zodError)) {
     throw new TypeError(
@@ -10683,26 +11153,22 @@ function fromZodError(zodError, options = {}) {
   return fromZodErrorWithoutRuntimeCheck(zodError, options);
 }
 function fromZodErrorWithoutRuntimeCheck(zodError, options = {}) {
-  const {
-    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE,
-    issueSeparator = ISSUE_SEPARATOR,
-    unionSeparator = UNION_SEPARATOR,
-    prefixSeparator = PREFIX_SEPARATOR,
-    prefix = PREFIX,
-    includePath = true
-  } = options;
   const zodIssues = zodError.errors;
-  const reason = zodIssues.length === 0 ? zodError.message : zodIssues.slice(0, maxIssuesInMessage).map(
-    (issue) => getMessageFromZodIssue({
-      issue,
-      issueSeparator,
-      unionSeparator,
-      includePath
-    })
-  ).join(issueSeparator);
-  const message = prefixMessage(reason, prefix, prefixSeparator);
+  let message;
+  if (isNonEmptyArray(zodIssues)) {
+    const messageBuilder = createMessageBuilderFromOptions2(options);
+    message = messageBuilder(zodIssues);
+  } else {
+    message = zodError.message;
+  }
   return new ValidationError(message, { cause: zodError });
 }
+function createMessageBuilderFromOptions2(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
 var toValidationError = (options = {}) => (err) => {
   if (isZodErrorLike(err)) {
     return fromZodErrorWithoutRuntimeCheck(err, options);
@@ -10782,40 +11248,40 @@ 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,
@@ -11068,14 +11534,14 @@ 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_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(
@@ -11330,11 +11796,39 @@ var LimitChunkCountPlugin = create2(
 
 // src/builtin-plugin/MangleExportsPlugin.ts
 var import_binding48 = require("@rspack/binding");
-var MangleExportsPlugin = create2(
-  import_binding48.BuiltinPluginName.MangleExportsPlugin,
-  (deterministic) => deterministic,
-  "compilation"
-);
+var MangleExportsPlugin = class extends RspackBuiltinPlugin {
+  constructor(deterministic) {
+    super();
+    this.deterministic = deterministic;
+    this.name = import_binding48.BuiltinPluginName.MangleExportsPlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.MangleExportsPlugin"
+    );
+    if (incremental2.modulesHashes) {
+      incremental2.modulesHashes = false;
+      logger.warn(
+        "`optimization.mangleExports` can't be used with `incremental.modulesHashes` as export mangling is a global effect. `incremental.modulesHashes` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesCodegen) {
+      incremental2.modulesCodegen = false;
+      logger.warn(
+        "`optimization.mangleExports` can't be used with `incremental.modulesCodegen` as export mangling is a global effect. `incremental.modulesCodegen` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesRuntimeRequirements) {
+      incremental2.modulesRuntimeRequirements = false;
+      logger.warn(
+        "`optimization.mangleExports` can't be used with `incremental.modulesRuntimeRequirements` as export mangling is a global effect. `incremental.modulesRuntimeRequirements` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, this.deterministic);
+  }
+};
 
 // src/builtin-plugin/MergeDuplicateChunksPlugin.ts
 var import_binding49 = require("@rspack/binding");
@@ -11354,12 +11848,38 @@ var ModuleChunkFormatPlugin = create2(
 
 // src/builtin-plugin/ModuleConcatenationPlugin.ts
 var import_binding51 = require("@rspack/binding");
-var ModuleConcatenationPlugin = create2(
-  import_binding51.BuiltinPluginName.ModuleConcatenationPlugin,
-  () => {
-  },
-  "compilation"
-);
+var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
+  constructor() {
+    super(...arguments);
+    this.name = import_binding51.BuiltinPluginName.ModuleConcatenationPlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.ModuleConcatenationPlugin"
+    );
+    if (incremental2.modulesHashes) {
+      incremental2.modulesHashes = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.modulesHashes` as module concatenation is a global effect. `incremental.modulesHashes` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesCodegen) {
+      incremental2.modulesCodegen = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.modulesCodegen` as module concatenation is a global effect. `incremental.modulesCodegen` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesRuntimeRequirements) {
+      incremental2.modulesRuntimeRequirements = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.modulesRuntimeRequirements` as module concatenation is a global effect. `incremental.modulesRuntimeRequirements` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, void 0);
+  }
+};
 
 // src/builtin-plugin/NamedChunkIdsPlugin.ts
 var import_binding52 = require("@rspack/binding");
@@ -11881,6 +12401,43 @@ var ContextReplacementPlugin = create2(
   }
 );
 
+// src/builtin-plugin/LibManifestPlugin.ts
+var import_binding76 = require("@rspack/binding");
+var LibManifestPlugin = create2(
+  import_binding76.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/builtin-plugin/DllEntryPlugin.ts
+var import_binding77 = require("@rspack/binding");
+var DllEntryPlugin = create2(
+  import_binding77.BuiltinPluginName.DllEntryPlugin,
+  (context2, entries, options) => {
+    return {
+      context: context2,
+      entries,
+      name: options.name
+    };
+  }
+);
+
+// src/builtin-plugin/DllReferenceAgencyPlugin.ts
+var import_binding78 = require("@rspack/binding");
+var DllReferenceAgencyPlugin = create2(
+  import_binding78.BuiltinPluginName.DllReferenceAgencyPlugin,
+  (options) => options
+);
+
 // src/ContextModuleFactory.ts
 var liteTapable5 = __toESM(require("@rspack/lite-tapable"));
 var ContextModuleFactory = class {
@@ -12524,6 +13081,7 @@ var checkVersion = () => {
 };
 
 // src/Compiler.ts
+var COMPILATION_WEAK_MAP = /* @__PURE__ */ new WeakMap();
 var Compiler = class _Compiler {
   #instance;
   #initial;
@@ -12601,6 +13159,9 @@ var Compiler = class _Compiler {
     this.watchMode = false;
     new JsLoaderRspackPlugin(this).apply(this);
     new ExecuteModulePlugin().apply(this);
+    this.hooks.shutdown.tap("rspack:cleanup", () => {
+      this.#instance = void 0;
+    });
   }
   get recordsInputPath() {
     return unsupported("Compiler.recordsInputPath");
@@ -12990,8 +13551,12 @@ var Compiler = class _Compiler {
     });
   }
   #createCompilation(native) {
-    const compilation = new Compilation(this, native);
-    compilation.name = this.name;
+    let compilation = COMPILATION_WEAK_MAP.get(native);
+    if (!compilation) {
+      compilation = new Compilation(this, native);
+      compilation.name = this.name;
+      COMPILATION_WEAK_MAP.set(native, compilation);
+    }
     this.#compilation = compilation;
     return compilation;
   }
@@ -13031,467 +13596,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) => {
-          if (this.#compilation === void 0) {
-            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
+                ) || {}
+              }
+            });
+          };
         }
       )
     };
@@ -13540,7 +14435,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 = [
@@ -13560,7 +14457,7 @@ var Compiler = class _Compiler {
           stage: liteTapable7.safeStage(from + 1)
         });
       }
-      this.#decorateJsTaps(jsTaps);
+      compiler.#decorateJsTaps(jsTaps);
       return jsTaps;
     };
     getTaps.registerKind = registerKind;
@@ -13568,7 +14465,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 = [
@@ -13588,7 +14487,7 @@ var Compiler = class _Compiler {
           stage: liteTapable7.safeStage(from + 1)
         });
       }
-      this.#decorateJsTaps(jsTaps);
+      compiler.#decorateJsTaps(jsTaps);
       return jsTaps;
     };
     getTaps.registerKind = registerKind;
@@ -14775,6 +15674,7 @@ var MODULES_GROUPERS = (type) => ({
       groupModulesByAttributes,
       groupModulesByType,
       groupModulesByPath,
+      groupModulesByLayer,
       groupModulesByExtension
     } = options;
     if (groupModulesByAttributes) {
@@ -14827,6 +15727,20 @@ var MODULES_GROUPERS = (type) => ({
         }
       });
     }
+    if (groupModulesByLayer) {
+      groupConfigs.push({
+        getKeys: (module2) => (
+          /** @type {string[]} */
+          [module2.layer]
+        ),
+        createGroup: (key, children, _modules) => ({
+          type: "modules by layer",
+          layer: key,
+          children,
+          ...moduleGroup(children)
+        })
+      });
+    }
     if (groupModulesByPath || groupModulesByExtension) {
       groupConfigs.push({
         getKeys: (module2) => {
@@ -17305,10 +18219,7 @@ var RspackOptionsApply = class {
         typeof lazyOptions.test === "function" ? (jsModule) => lazyOptions.test.call(
           lazyOptions,
           new Module(jsModule)
-        ) : lazyOptions.test ? {
-          source: lazyOptions.test.source,
-          flags: lazyOptions.test.flags
-        } : void 0,
+        ) : lazyOptions.test,
         lazyOptions.backend
       ).apply(compiler);
     }
@@ -17405,6 +18316,203 @@ var RspackOptionsApply = class {
   }
 };
 
+// src/lib/DllPlugin.ts
+var import_zod5 = __toESM(require("../compiled/zod/index.js"));
+
+// src/builtin-plugin/FlagAllModulesAsUsedPlugin.ts
+var import_binding79 = require("@rspack/binding");
+var FlagAllModulesAsUsedPlugin = create2(
+  import_binding79.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) {
@@ -18103,9 +19211,9 @@ var NodeTemplatePlugin = class {
 };
 
 // src/container/ModuleFederationRuntimePlugin.ts
-var import_binding76 = require("@rspack/binding");
+var import_binding80 = require("@rspack/binding");
 var ModuleFederationRuntimePlugin = create2(
-  import_binding76.BuiltinPluginName.ModuleFederationRuntimePlugin,
+  import_binding80.BuiltinPluginName.ModuleFederationRuntimePlugin,
   () => {
   }
 );
@@ -18301,10 +19409,10 @@ function getDefaultEntryRuntime(paths, options, compiler) {
 }
 
 // src/sharing/ConsumeSharedPlugin.ts
-var import_binding78 = require("@rspack/binding");
+var import_binding82 = require("@rspack/binding");
 
 // src/sharing/ShareRuntimePlugin.ts
-var import_binding77 = require("@rspack/binding");
+var import_binding81 = require("@rspack/binding");
 var compilerSet = /* @__PURE__ */ new WeakSet();
 function isSingleton(compiler) {
   return compilerSet.has(compiler);
@@ -18316,7 +19424,7 @@ var ShareRuntimePlugin = class extends RspackBuiltinPlugin {
   constructor(enhanced = false) {
     super();
     this.enhanced = enhanced;
-    this.name = import_binding77.BuiltinPluginName.ShareRuntimePlugin;
+    this.name = import_binding81.BuiltinPluginName.ShareRuntimePlugin;
   }
   raw(compiler) {
     if (isSingleton(compiler)) return;
@@ -18335,7 +19443,7 @@ function isRequiredVersion(str) {
 var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding78.BuiltinPluginName.ConsumeSharedPlugin;
+    this.name = import_binding82.BuiltinPluginName.ConsumeSharedPlugin;
     this._options = {
       consumes: parseOptions(
         options.consumes,
@@ -18398,11 +19506,11 @@ var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/sharing/ProvideSharedPlugin.ts
-var import_binding79 = require("@rspack/binding");
+var import_binding83 = require("@rspack/binding");
 var ProvideSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding79.BuiltinPluginName.ProvideSharedPlugin;
+    this.name = import_binding83.BuiltinPluginName.ProvideSharedPlugin;
     this._provides = parseOptions(
       options.provides,
       (item) => {
@@ -18507,11 +19615,11 @@ var SharePlugin = class {
 };
 
 // src/container/ContainerPlugin.ts
-var import_binding80 = require("@rspack/binding");
+var import_binding84 = require("@rspack/binding");
 var ContainerPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding80.BuiltinPluginName.ContainerPlugin;
+    this.name = import_binding84.BuiltinPluginName.ContainerPlugin;
     this._options = {
       name: options.name,
       shareScope: options.shareScope || "default",
@@ -18555,11 +19663,11 @@ var ContainerPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/container/ContainerReferencePlugin.ts
-var import_binding81 = require("@rspack/binding");
+var import_binding85 = require("@rspack/binding");
 var ContainerReferencePlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding81.BuiltinPluginName.ContainerReferencePlugin;
+    this.name = import_binding85.BuiltinPluginName.ContainerReferencePlugin;
     this._options = {
       remoteType: options.remoteType,
       remotes: parseOptions(
@@ -18644,7 +19752,7 @@ var ModuleFederationPluginV1 = class {
 };
 
 // src/exports.ts
-var import_binding82 = require("@rspack/binding");
+var import_binding86 = require("@rspack/binding");
 var rspackVersion = import_package.version;
 var version = import_package.webpackVersion;
 var WebpackError2 = Error;
@@ -18690,8 +19798,8 @@ var sharing = {
 };
 var experiments2 = {
   globalTrace: {
-    register: import_binding82.registerGlobalTrace,
-    cleanup: import_binding82.cleanupGlobalTrace
+    register: import_binding86.registerGlobalTrace,
+    cleanup: import_binding86.cleanupGlobalTrace
   },
   RemoveDuplicateModulesPlugin
 };
@@ -18812,6 +19920,8 @@ module.exports = rspack;
   CopyRspackPlugin,
   CssExtractRspackPlugin,
   DefinePlugin,
+  DllPlugin,
+  DllReferencePlugin,
   DynamicEntryPlugin,
   EntryOptionPlugin,
   EntryPlugin,