@rspack/core 1.2.3 → 1.2.4

package/dist/index.js

@@ -600,9 +600,9 @@ var require_CachedInputFileSystem = __commonJS({
         const readFile = this._readFileBackend.provide;
         this.readFile = /** @type {FileSystem["readFile"]} */
         readFile;
-        const readFileSync2 = this._readFileBackend.provideSync;
+        const readFileSync3 = this._readFileBackend.provideSync;
         this.readFileSync = /** @type {SyncFileSystem["readFileSync"]} */
-        readFileSync2;
+        readFileSync3;
         this._readJsonBackend = createBackend(
           duration,
           // prettier-ignore
@@ -1506,6 +1506,14 @@ var Chunk = class _Chunk {
   }
 };
 
+// src/util/runtime.ts
+function toJsRuntimeSpec(runtime) {
+  if (runtime instanceof Set) {
+    return Array.from(runtime);
+  }
+  return runtime;
+}
+
 // src/ChunkGraph.ts
 var ChunkGraph = class _ChunkGraph {
   #inner;
@@ -1545,6 +1553,12 @@ var ChunkGraph = class _ChunkGraph {
   getModuleId(module2) {
     return this.#inner.getModuleId(Module.__to_binding(module2));
   }
+  getModuleHash(module2, runtime) {
+    return this.#inner.getModuleHash(
+      Module.__to_binding(module2),
+      toJsRuntimeSpec(runtime)
+    );
+  }
   getBlockChunkGroup(depBlock) {
     const binding9 = this.#inner.getBlockChunkGroup(
       DependenciesBlock.__to_binding(depBlock)
@@ -1599,16 +1613,16 @@ var ExportsInfo = class _ExportsInfo {
     this.#inner = binding9;
   }
   isUsed(runtime) {
-    return this.#inner.isUsed(runtime);
+    return this.#inner.isUsed(toJsRuntimeSpec(runtime));
   }
   isModuleUsed(runtime) {
-    return this.#inner.isModuleUsed(runtime);
+    return this.#inner.isModuleUsed(toJsRuntimeSpec(runtime));
   }
   setUsedInUnknownWay(runtime) {
-    return this.#inner.setUsedInUnknownWay(runtime);
+    return this.#inner.setUsedInUnknownWay(toJsRuntimeSpec(runtime));
   }
   getUsed(name2, runtime) {
-    return this.#inner.getUsed(name2, runtime);
+    return this.#inner.getUsed(name2, toJsRuntimeSpec(runtime));
   }
 };
 
@@ -2831,22 +2845,40 @@ var StatsPrinter = class {
   }
 };
 
-// src/util/MergeCaller.ts
-var MergeCaller = class {
-  constructor(fn2) {
-    this.callArgs = [];
-    this.finalCall = () => {
-      const args = this.callArgs;
-      this.callArgs = [];
-      this.callFn(args);
-    };
-    this.callFn = fn2;
+// src/util/AsyncTask.ts
+var AsyncTask = class {
+  #isRunning = false;
+  #params = [];
+  #callbacks = [];
+  #task;
+  constructor(task) {
+    this.#task = task;
+  }
+  #exec_internal() {
+    const params = this.#params;
+    const callbacks = this.#callbacks;
+    this.#params = [];
+    this.#callbacks = [];
+    this.#task(params, (results) => {
+      this.#isRunning = false;
+      if (this.#params.length) {
+        this.#isRunning = true;
+        queueMicrotask(() => this.#exec_internal());
+      }
+      for (let i = 0; i < results.length; i++) {
+        const [err, result2] = results[i];
+        const callback = callbacks[i];
+        callback(err, result2);
+      }
+    });
   }
-  push(...data) {
-    if (this.callArgs.length === 0) {
-      queueMicrotask(this.finalCall);
+  exec(param, callback) {
+    if (!this.#isRunning) {
+      queueMicrotask(() => this.#exec_internal());
+      this.#isRunning = true;
     }
-    this.callArgs.push(...data);
+    this.#params.push(param);
+    this.#callbacks.push(callback);
   }
 };
 
@@ -2877,6 +2909,25 @@ function createReadonlyMap(obj) {
   };
 }
 
+// src/util/MergeCaller.ts
+var MergeCaller = class {
+  constructor(fn2) {
+    this.callArgs = [];
+    this.finalCall = () => {
+      const args = this.callArgs;
+      this.callArgs = [];
+      this.callFn(args);
+    };
+    this.callFn = fn2;
+  }
+  push(...data) {
+    if (this.callArgs.length === 0) {
+      queueMicrotask(this.finalCall);
+    }
+    this.callArgs.push(...data);
+  }
+};
+
 // src/util/fake.ts
 function createFakeCompilationDependencies(getDeps, addDeps) {
   const addDepsCaller = new MergeCaller(addDeps);
@@ -2900,7 +2951,7 @@ function createFakeCompilationDependencies(getDeps, addDeps) {
 }
 
 // src/Compilation.ts
-var _inner, _shutdown, _addIncludeDispatcher, _Compilation_instances, createCachedAssets_fn, _rebuildModuleCaller;
+var _inner, _shutdown, _addIncludeDispatcher, _Compilation_instances, createCachedAssets_fn, _rebuildModuleTask;
 var _Compilation = class _Compilation {
   constructor(compiler, inner) {
     __privateAdd(this, _Compilation_instances);
@@ -2928,23 +2979,22 @@ var _Compilation = class _Compilation {
       () => __privateGet(this, _inner).dependencies().buildDependencies,
       (d) => __privateGet(this, _inner).addBuildDependencies(d)
     );
-    __privateAdd(this, _rebuildModuleCaller, ((compilation) => new MergeCaller(
-      (args) => {
-        __privateGet(compilation, _inner).rebuildModule(
-          args.map((item) => item[0]),
+    __privateAdd(this, _rebuildModuleTask, new AsyncTask(
+      (moduleIdentifiers, doneWork) => {
+        __privateGet(this, _inner).rebuildModule(
+          moduleIdentifiers,
           (err, modules) => {
-            for (const [id, callback] of args) {
-              const m = modules.find((item) => item.moduleIdentifier === id);
-              if (m) {
-                callback(err, Module.__from_binding(m));
-              } else {
-                callback(err || new Error("module no found"), null);
-              }
+            if (err) {
+              doneWork(new Array(moduleIdentifiers.length).fill([err, null]));
+            } else {
+              doneWork(
+                modules.map((jsModule) => [null, Module.__from_binding(jsModule)])
+              );
             }
           }
         );
       }
-    ))(this));
+    ));
     __privateSet(this, _inner, inner);
     __privateSet(this, _shutdown, false);
     const processAssetsHook = new liteTapable.AsyncSeriesHook([
@@ -3575,7 +3625,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     );
   }
   rebuildModule(m, f) {
-    __privateGet(this, _rebuildModuleCaller).push([m.identifier(), f]);
+    __privateGet(this, _rebuildModuleTask).exec(m.identifier(), f);
   }
   addRuntimeModule(chunk, runtimeModule) {
     runtimeModule.attach(this, chunk, this.chunkGraph);
@@ -3713,7 +3763,7 @@ createCachedAssets_fn = function() {
     }
   );
 };
-_rebuildModuleCaller = new WeakMap();
+_rebuildModuleTask = new WeakMap();
 _Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2e3;
 _Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS = -1e3;
 _Compilation.PROCESS_ASSETS_STAGE_DERIVED = -200;
@@ -3746,7 +3796,7 @@ var AddIncludeDispatcher = class {
     this.#cbs = [];
     this.#inner(args, (wholeErr, results) => {
       if (this.#args.length !== 0) {
-        queueMicrotask(this.#execute);
+        queueMicrotask(this.#execute.bind(this));
       }
       if (wholeErr) {
         const webpackError = new WebpackError_default(wholeErr.message);
@@ -3771,7 +3821,7 @@ var AddIncludeDispatcher = class {
   }
   call(context2, dependency, options, callback) {
     if (this.#args.length === 0) {
-      queueMicrotask(this.#execute);
+      queueMicrotask(this.#execute.bind(this));
     }
     this.#args.push([context2, dependency, options]);
     this.#cbs.push(callback);
@@ -3846,7 +3896,9 @@ var liteTapable9 = __toESM(require("@rspack/lite-tapable"));
 var import_node_vm = __toESM(require("vm"));
 var ExecuteModulePlugin = class {
   apply(compiler) {
-    compiler.hooks.compilation.tap("executeModule", (compilation) => {
+    compiler.hooks.thisCompilation.tap("executeModule", (compilation) => {
+      const map = compiler.__internal__get_module_execution_results_map();
+      map.clear();
       compilation.hooks.executeModule.tap(
         "executeModule",
         (options, context2) => {
@@ -5953,7 +6005,7 @@ async function runLoaders(compiler, context2) {
   };
   loaderContext.importModule = function importModule(request, userOptions, callback) {
     const options = userOptions ? userOptions : {};
-    const context3 = this;
+    const context3 = loaderContext;
     function finalCallback(onError, onDone) {
       return function(err, res) {
         if (err) {
@@ -6117,7 +6169,7 @@ async function runLoaders(compiler, context2) {
       loaderContext.loaders[loaderContext.loaderIndex]
     )})`;
     error = concatErrorMsgAndStack(error);
-    error.moduleIdentifier = this._module.identifier();
+    error.moduleIdentifier = loaderContext._module.identifier();
     compiler._lastCompilation.__internal__pushRspackDiagnostic({
       error,
       severity: import_binding2.JsRspackSeverity.Error
@@ -6133,7 +6185,7 @@ async function runLoaders(compiler, context2) {
       loaderContext.loaders[loaderContext.loaderIndex]
     )})`;
     warning = concatErrorMsgAndStack(warning);
-    warning.moduleIdentifier = this._module.identifier();
+    warning.moduleIdentifier = loaderContext._module.identifier();
     compiler._lastCompilation.__internal__pushRspackDiagnostic({
       error: warning,
       severity: import_binding2.JsRspackSeverity.Warn
@@ -6148,7 +6200,7 @@ async function runLoaders(compiler, context2) {
           makePathsRelative(contextDirectory, sourceMap, compiler)
         );
       }
-      if (this.sourceMap) {
+      if (loaderContext.sourceMap) {
         source = new import_webpack_sources2.SourceMapSource(
           // @ts-expect-error webpack-sources type declaration is wrong
           content,
@@ -6999,8 +7051,8 @@ function getRawStats(stats) {
 
 // src/config/defaults.ts
 var import_node_assert6 = __toESM(require("assert"));
-var import_node_fs2 = __toESM(require("fs"));
-var import_node_path8 = __toESM(require("path"));
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path9 = __toESM(require("path"));
 
 // src/ModuleTypeConstants.ts
 var JSON_MODULE_TYPE = "json";
@@ -8809,14 +8861,30 @@ var LazyCompilationPlugin = class {
       this.test
     ).apply(compiler);
     let initialized = false;
+    const initBackendPromise = new Promise((resolve2, reject) => {
+      backend(compiler, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          initialized = true;
+          resolve2();
+        }
+      });
+    });
     compiler.hooks.beforeCompile.tapAsync(
       "LazyCompilationPlugin",
       (_params, callback) => {
-        if (initialized) return callback();
-        backend(compiler, (err, result2) => {
-          if (err) return callback(err);
-          initialized = true;
+        if (initialized) {
+          return callback();
+        }
+        initBackendPromise.then(() => {
           callback();
+        }).catch((err) => {
+          const logger = compiler.getInfrastructureLogger(
+            "LazyCompilationBackend"
+          );
+          logger.error("Failed to listen to lazy compilation server.");
+          callback(err);
         });
       }
     );
@@ -9238,10 +9306,11 @@ function toRawSplitChunksOptions(sc, compiler) {
   function getTest(test) {
     if (typeof test === "function") {
       return (ctx) => {
-        if (typeof ctx.module === "undefined") {
-          return test(void 0);
-        }
-        return test(Module.__from_binding(ctx.module));
+        const info = {
+          moduleGraph: compiler._lastCompilation.moduleGraph,
+          chunkGraph: compiler._lastCompilation.chunkGraph
+        };
+        return test(Module.__from_binding(ctx.module), info);
       };
     }
     return test;
@@ -9666,6 +9735,226 @@ var createRsdoctorPluginHooksRegisters = (getCompiler, createTap, createMapTap)
   };
 };
 
+// src/builtin-plugin/SubresourceIntegrityPlugin.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_path7 = require("path");
+var import_binding74 = require("@rspack/binding");
+var import_zod4 = require("../compiled/zod/index.js");
+var PLUGIN_NAME2 = "SubresourceIntegrityPlugin";
+var NATIVE_HTML_PLUGIN = "HtmlRspackPlugin";
+var hashFunctionSchema = import_zod4.z.enum(["sha256", "sha384", "sha512"]);
+var pluginOptionsSchema2 = import_zod4.z.object({
+  hashFuncNames: import_zod4.z.tuple([hashFunctionSchema]).rest(hashFunctionSchema).optional(),
+  htmlPlugin: import_zod4.z.string().or(import_zod4.z.literal(false)).optional(),
+  enabled: import_zod4.z.literal("auto").or(import_zod4.z.boolean()).optional()
+});
+var NativeSubresourceIntegrityPlugin = create2(
+  import_binding74.BuiltinPluginName.SubresourceIntegrityPlugin,
+  function(options) {
+    let htmlPlugin = "Disabled";
+    if (options.htmlPlugin === NATIVE_HTML_PLUGIN) {
+      htmlPlugin = "Native";
+    } else if (typeof options.htmlPlugin === "string") {
+      htmlPlugin = "JavaScript";
+    }
+    return {
+      hashFuncNames: options.hashFuncNames,
+      htmlPlugin,
+      integrityCallback: options.integrityCallback
+    };
+  }
+);
+var SubresourceIntegrityPlugin = class extends NativeSubresourceIntegrityPlugin {
+  constructor(options) {
+    let validateError = null;
+    if (typeof options !== "object") {
+      throw new Error("SubResourceIntegrity: argument must be an object");
+    }
+    try {
+      validateSubresourceIntegrityPluginOptions(options);
+    } catch (e) {
+      validateError = e;
+    }
+    const finalOptions = validateError ? {
+      hashFuncNames: ["sha384"],
+      htmlPlugin: NATIVE_HTML_PLUGIN,
+      enabled: false
+    } : {
+      hashFuncNames: options.hashFuncNames ?? ["sha384"],
+      htmlPlugin: options.htmlPlugin ?? NATIVE_HTML_PLUGIN,
+      enabled: options.enabled ?? "auto"
+    };
+    super({
+      ...finalOptions,
+      integrityCallback: (data) => {
+        this.integrities = new Map(
+          data.integerities.map((item) => [item.asset, item.integrity])
+        );
+      }
+    });
+    this.integrities = /* @__PURE__ */ new Map();
+    this.validateError = null;
+    this.validateError = validateError;
+    this.options = finalOptions;
+  }
+  isEnabled(compiler) {
+    if (this.options.enabled === "auto") {
+      return compiler.options.mode !== "development";
+    }
+    return this.options.enabled;
+  }
+  getIntegrityChecksumForAsset(src) {
+    if (this.integrities.has(src)) {
+      return this.integrities.get(src);
+    }
+    const normalizedSrc = normalizePath(src);
+    const normalizedKey = Array.from(this.integrities.keys()).find(
+      (assetKey) => normalizePath(assetKey) === normalizedSrc
+    );
+    return normalizedKey ? this.integrities.get(normalizedKey) : void 0;
+  }
+  handleHwpPluginArgs({ assets }) {
+    const publicPath2 = assets.publicPath;
+    const jsIntegrity = [];
+    for (const asset of assets.js) {
+      jsIntegrity.push(
+        this.getIntegrityChecksumForAsset(
+          (0, import_node_path7.relative)(publicPath2, decodeURIComponent(asset))
+        )
+      );
+    }
+    const cssIntegrity = [];
+    for (const asset of assets.css) {
+      cssIntegrity.push(
+        this.getIntegrityChecksumForAsset(
+          (0, import_node_path7.relative)(publicPath2, decodeURIComponent(asset))
+        )
+      );
+    }
+    assets.jsIntegrity = jsIntegrity;
+    assets.cssIntegrity = cssIntegrity;
+  }
+  handleHwpBodyTags({ headTags, bodyTags, publicPath: publicPath2 }, outputPath, crossOriginLoading2) {
+    for (const tag of headTags.concat(bodyTags)) {
+      this.processTag(tag, publicPath2, outputPath, crossOriginLoading2);
+    }
+  }
+  processTag(tag, publicPath2, outputPath, crossOriginLoading2) {
+    if (tag.attributes && "integrity" in tag.attributes) {
+      return;
+    }
+    const tagSrc = getTagSrc(tag);
+    if (!tagSrc) {
+      return;
+    }
+    const src = (0, import_node_path7.relative)(publicPath2, decodeURIComponent(tagSrc));
+    tag.attributes.integrity = this.getIntegrityChecksumForAsset(src) || computeIntegrity(
+      this.options.hashFuncNames,
+      (0, import_node_fs2.readFileSync)((0, import_node_path7.join)(outputPath, src))
+    );
+    tag.attributes.crossorigin = crossOriginLoading2 || "anonymous";
+  }
+  apply(compiler) {
+    if (!this.isEnabled(compiler)) {
+      if (this.validateError) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME2, (compilation) => {
+          compilation.errors.push(
+            this.validateError
+          );
+        });
+      }
+      return;
+    }
+    super.apply(compiler);
+    compiler.hooks.compilation.tap(PLUGIN_NAME2, (compilation) => {
+      compilation.hooks.statsFactory.tap(PLUGIN_NAME2, (statsFactory) => {
+        statsFactory.hooks.extract.for("asset").tap(PLUGIN_NAME2, (object, asset) => {
+          var _a;
+          const contenthash = (_a = asset.info) == null ? void 0 : _a.contenthash;
+          if (contenthash) {
+            const shaHashes = (Array.isArray(contenthash) ? contenthash : [contenthash]).filter((hash) => String(hash).match(/^sha[0-9]+-/));
+            if (shaHashes.length > 0) {
+              object.integrity = shaHashes.join(" ");
+            }
+          }
+        });
+      });
+    });
+    if (typeof this.options.htmlPlugin === "string" && this.options.htmlPlugin !== NATIVE_HTML_PLUGIN) {
+      let getHooks = null;
+      try {
+        const htmlPlugin = require(this.options.htmlPlugin);
+        getHooks = htmlPlugin.getCompilationHooks || htmlPlugin.getHooks;
+      } catch (e) {
+        if (!isErrorWithCode(e) || e.code !== "MODULE_NOT_FOUND") {
+          throw e;
+        }
+      }
+      if (typeof getHooks === "function") {
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME2, (compilation) => {
+          if (typeof compiler.options.output.chunkLoading === "string" && ["require", "async-node"].includes(
+            compiler.options.output.chunkLoading
+          )) {
+            return;
+          }
+          const hwpHooks = getHooks(compilation);
+          hwpHooks.beforeAssetTagGeneration.tapPromise(
+            PLUGIN_NAME2,
+            async (data) => {
+              this.handleHwpPluginArgs(data);
+              return data;
+            }
+          );
+          hwpHooks.alterAssetTagGroups.tapPromise(
+            {
+              name: PLUGIN_NAME2,
+              stage: 1e4
+            },
+            async (data) => {
+              this.handleHwpBodyTags(
+                data,
+                compiler.outputPath,
+                compiler.options.output.crossOriginLoading
+              );
+              return data;
+            }
+          );
+        });
+      }
+    }
+  }
+};
+function validateSubresourceIntegrityPluginOptions(options) {
+  validate(options, pluginOptionsSchema2);
+}
+function isErrorWithCode(obj) {
+  return obj instanceof Error && "code" in obj && ["string", "undefined"].includes(typeof obj.code);
+}
+function getTagSrc(tag) {
+  if (!["script", "link"].includes(tag.tagName) || !tag.attributes) {
+    return void 0;
+  }
+  if (typeof tag.attributes.href === "string") {
+    return tag.attributes.href;
+  }
+  if (typeof tag.attributes.src === "string") {
+    return tag.attributes.src;
+  }
+  return void 0;
+}
+function computeIntegrity(hashFuncNames, source) {
+  const result2 = hashFuncNames.map(
+    (hashFuncName) => `${hashFuncName}-${(0, import_node_crypto2.createHash)(hashFuncName).update(
+      typeof source === "string" ? Buffer.from(source, "utf-8") : source
+    ).digest("base64")}`
+  ).join(" ");
+  return result2;
+}
+function normalizePath(path11) {
+  return path11.replace(/\?.*$/, "").split(import_node_path7.sep).join("/");
+}
+
 // src/util/assertNotNil.ts
 function assertNotNill(value) {
   if (value == null) {
@@ -10000,13 +10289,13 @@ __export(browserslistTargetHandler_exports, {
   load: () => load,
   resolve: () => resolve
 });
-var import_node_path7 = __toESM(require("path"));
+var import_node_path8 = __toESM(require("path"));
 var inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
 var parse = (input, context2) => {
   if (!input) {
     return {};
   }
-  if (import_node_path7.default.isAbsolute(input)) {
+  if (import_node_path8.default.isAbsolute(input)) {
     const [, configPath, env] = inputRx.exec(input) || [];
     return { configPath, env };
   }
@@ -10944,9 +11233,9 @@ var applyOutputDefaults = (output2, {
       }
     );
     if (libraryName2) return libraryName2;
-    const pkgPath = import_node_path8.default.resolve(context2, "package.json");
+    const pkgPath = import_node_path9.default.resolve(context2, "package.json");
     try {
-      const packageInfo = JSON.parse(import_node_fs2.default.readFileSync(pkgPath, "utf-8"));
+      const packageInfo = JSON.parse(import_node_fs3.default.readFileSync(pkgPath, "utf-8"));
       return packageInfo.name || "";
     } catch (err) {
       const e = err;
@@ -11000,7 +11289,7 @@ while determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
   D(output2, "assetModuleFilename", "[hash][ext][query]");
   D(output2, "webassemblyModuleFilename", "[hash].module.wasm");
   D(output2, "compareBeforeEmit", true);
-  F(output2, "path", () => import_node_path8.default.join(process.cwd(), "dist"));
+  F(output2, "path", () => import_node_path9.default.join(process.cwd(), "dist"));
   F(output2, "pathinfo", () => development);
   D(
     output2,
@@ -11087,8 +11376,7 @@ ${helpMessage}`
   F(output2, "wasmLoading", () => {
     if (tp) {
       if (tp.fetchWasm) return "fetch";
-      if (tp.nodeBuiltins)
-        return output2.module ? "async-node-module" : "async-node";
+      if (tp.nodeBuiltins) return "async-node";
       if (tp.nodeBuiltins === null || tp.fetchWasm === null) {
         return "universal";
       }
@@ -11476,7 +11764,7 @@ var getPnpDefault = () => {
 };
 
 // src/config/normalization.ts
-var import_node_path9 = __toESM(require("path"));
+var import_node_path10 = __toESM(require("path"));
 var import_node_util5 = __toESM(require("util"));
 var getNormalizedRspackOptions = (config2) => {
   return {
@@ -11666,7 +11954,7 @@ var getNormalizedRspackOptions = (config2) => {
           type: "persistent",
           buildDependencies: nestedArray(
             cache.buildDependencies,
-            (deps) => deps.map((d) => import_node_path9.default.resolve(config2.context || process.cwd(), d))
+            (deps) => deps.map((d) => import_node_path10.default.resolve(config2.context || process.cwd(), d))
           ),
           version: cache.version || "",
           snapshot: {
@@ -11678,7 +11966,7 @@ var getNormalizedRspackOptions = (config2) => {
           },
           storage: {
             type: "filesystem",
-            directory: import_node_path9.default.resolve(
+            directory: import_node_path10.default.resolve(
               config2.context || process.cwd(),
               ((_a = cache.storage) == null ? void 0 : _a.directory) || "node_modules/.cache/rspack"
             )
@@ -11808,11 +12096,11 @@ var keyedNestedConfig = (value, fn2, customKeys) => {
 };
 
 // src/config/zod.ts
-var import_node_path10 = __toESM(require("path"));
-var import_zod5 = require("../compiled/zod/index.js");
+var import_node_path11 = __toESM(require("path"));
+var import_zod6 = require("../compiled/zod/index.js");
 
 // src/config/utils.ts
-var import_zod4 = require("../compiled/zod/index.js");
+var import_zod5 = require("../compiled/zod/index.js");
 function processCreateParams(params) {
   if (!params) return {};
   const { errorMap, invalid_type_error, required_error, description } = params;
@@ -11835,7 +12123,7 @@ function processCreateParams(params) {
   };
   return { errorMap: customMap, description };
 }
-var _RspackZodUnion = class _RspackZodUnion extends import_zod4.z.ZodUnion {
+var _RspackZodUnion = class _RspackZodUnion extends import_zod5.z.ZodUnion {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     const options = this._def.options;
@@ -11852,13 +12140,13 @@ var _RspackZodUnion = class _RspackZodUnion extends import_zod4.z.ZodUnion {
         }
       }
       const unionErrors2 = results.map(
-        (result2) => new import_zod4.ZodError(result2.ctx.common.issues)
+        (result2) => new import_zod5.ZodError(result2.ctx.common.issues)
       );
-      (0, import_zod4.addIssueToContext)(ctx, {
-        code: import_zod4.ZodIssueCode.invalid_union,
+      (0, import_zod5.addIssueToContext)(ctx, {
+        code: import_zod5.ZodIssueCode.invalid_union,
         unionErrors: unionErrors2
       });
-      return import_zod4.INVALID;
+      return import_zod5.INVALID;
     }
     if (ctx.common.async) {
       return Promise.all(
@@ -11912,24 +12200,24 @@ var _RspackZodUnion = class _RspackZodUnion extends import_zod4.z.ZodUnion {
       ctx.common.issues.push(...dirty.ctx.common.issues);
       return dirty.result;
     }
-    const unionErrors = issues.map((issues2) => new import_zod4.ZodError(issues2));
-    (0, import_zod4.addIssueToContext)(ctx, {
-      code: import_zod4.ZodIssueCode.invalid_union,
+    const unionErrors = issues.map((issues2) => new import_zod5.ZodError(issues2));
+    (0, import_zod5.addIssueToContext)(ctx, {
+      code: import_zod5.ZodIssueCode.invalid_union,
       unionErrors
     });
-    return import_zod4.INVALID;
+    return import_zod5.INVALID;
   }
 };
 _RspackZodUnion.create = (types, params) => {
   return new _RspackZodUnion({
     options: types,
-    typeName: import_zod4.ZodFirstPartyTypeKind.ZodUnion,
+    typeName: import_zod5.ZodFirstPartyTypeKind.ZodUnion,
     ...processCreateParams(params)
   });
 };
 var RspackZodUnion = _RspackZodUnion;
-import_zod4.ZodUnion.create = RspackZodUnion.create;
-var ZodRspackCrossChecker = class extends import_zod4.ZodType {
+import_zod5.ZodUnion.create = RspackZodUnion.create;
+var ZodRspackCrossChecker = class extends import_zod5.ZodType {
   constructor(params) {
     super(params);
     this.params = params;
@@ -11942,7 +12230,7 @@ var ZodRspackCrossChecker = class extends import_zod4.ZodType {
         const res = pattern.type._parse(input);
         const issues = typeof pattern.issue === "function" ? pattern.issue(res) : [];
         for (const issue of issues) {
-          (0, import_zod4.addIssueToContext)(ctx, issue);
+          (0, import_zod5.addIssueToContext)(ctx, issue);
         }
         return res;
       }
@@ -11959,54 +12247,54 @@ var ZodRspackCrossChecker = class extends import_zod4.ZodType {
 };
 
 // src/config/zod.ts
-var filenameTemplate = import_zod5.z.string();
+var filenameTemplate = import_zod6.z.string();
 var filename = filenameTemplate.or(
-  import_zod5.z.function().args(import_zod5.z.custom(), import_zod5.z.custom().optional()).returns(import_zod5.z.string())
+  import_zod6.z.function().args(import_zod6.z.custom(), import_zod6.z.custom().optional()).returns(import_zod6.z.string())
 );
-var name = import_zod5.z.string();
-var dependencies = import_zod5.z.array(name);
-var context = import_zod5.z.string().refine(
-  (val) => import_node_path10.default.isAbsolute(val),
+var name = import_zod6.z.string();
+var dependencies = import_zod6.z.array(name);
+var context = import_zod6.z.string().refine(
+  (val) => import_node_path11.default.isAbsolute(val),
   (val) => ({
     message: `The provided value ${JSON.stringify(val)} must be an absolute path.`
   })
 );
-var mode = import_zod5.z.enum([
+var mode = import_zod6.z.enum([
   "development",
   "production",
   "none"
 ]);
-var falsy = import_zod5.z.union([
-  import_zod5.z.literal(false),
-  import_zod5.z.literal(0),
-  import_zod5.z.literal(""),
-  import_zod5.z.null(),
-  import_zod5.z.undefined()
+var falsy = import_zod6.z.union([
+  import_zod6.z.literal(false),
+  import_zod6.z.literal(0),
+  import_zod6.z.literal(""),
+  import_zod6.z.null(),
+  import_zod6.z.undefined()
 ]);
-var publicPath = import_zod5.z.literal("auto").or(filename);
-var baseUri = import_zod5.z.string();
-var chunkLoadingType = import_zod5.z.enum(["jsonp", "import-scripts", "require", "async-node", "import"]).or(import_zod5.z.string());
-var chunkLoading = import_zod5.z.literal(false).or(chunkLoadingType);
-var asyncChunks = import_zod5.z.boolean();
-var wasmLoadingType = import_zod5.z.enum(["fetch-streaming", "fetch", "async-node"]).or(import_zod5.z.string());
-var wasmLoading = import_zod5.z.literal(false).or(wasmLoadingType);
-var scriptType = import_zod5.z.enum(["text/javascript", "module"]).or(import_zod5.z.literal(false));
-var libraryCustomUmdObject = import_zod5.z.strictObject({
-  amd: import_zod5.z.string().optional(),
-  commonjs: import_zod5.z.string().optional(),
-  root: import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string())).optional()
+var publicPath = import_zod6.z.literal("auto").or(filename);
+var baseUri = import_zod6.z.string();
+var chunkLoadingType = import_zod6.z.enum(["jsonp", "import-scripts", "require", "async-node", "import"]).or(import_zod6.z.string());
+var chunkLoading = import_zod6.z.literal(false).or(chunkLoadingType);
+var asyncChunks = import_zod6.z.boolean();
+var wasmLoadingType = import_zod6.z.enum(["fetch-streaming", "fetch", "async-node"]).or(import_zod6.z.string());
+var wasmLoading = import_zod6.z.literal(false).or(wasmLoadingType);
+var scriptType = import_zod6.z.enum(["text/javascript", "module"]).or(import_zod6.z.literal(false));
+var libraryCustomUmdObject = import_zod6.z.strictObject({
+  amd: import_zod6.z.string().optional(),
+  commonjs: import_zod6.z.string().optional(),
+  root: import_zod6.z.string().or(import_zod6.z.array(import_zod6.z.string())).optional()
 });
-var libraryName = import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string())).or(libraryCustomUmdObject);
-var libraryCustomUmdCommentObject = import_zod5.z.strictObject({
-  amd: import_zod5.z.string().optional(),
-  commonjs: import_zod5.z.string().optional(),
-  commonjs2: import_zod5.z.string().optional(),
-  root: import_zod5.z.string().optional()
+var libraryName = import_zod6.z.string().or(import_zod6.z.array(import_zod6.z.string())).or(libraryCustomUmdObject);
+var libraryCustomUmdCommentObject = import_zod6.z.strictObject({
+  amd: import_zod6.z.string().optional(),
+  commonjs: import_zod6.z.string().optional(),
+  commonjs2: import_zod6.z.string().optional(),
+  root: import_zod6.z.string().optional()
 });
-var amdContainer = import_zod5.z.string();
-var auxiliaryComment = import_zod5.z.string().or(libraryCustomUmdCommentObject);
-var libraryExport = import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string()));
-var libraryType = import_zod5.z.enum([
+var amdContainer = import_zod6.z.string();
+var auxiliaryComment = import_zod6.z.string().or(libraryCustomUmdCommentObject);
+var libraryExport = import_zod6.z.string().or(import_zod6.z.array(import_zod6.z.string()));
+var libraryType = import_zod6.z.enum([
   "var",
   "module",
   "assign",
@@ -12025,9 +12313,9 @@ var libraryType = import_zod5.z.enum([
   "umd2",
   "jsonp",
   "system"
-]).or(import_zod5.z.string());
-var umdNamedDefine = import_zod5.z.boolean();
-var libraryOptions = import_zod5.z.strictObject({
+]).or(import_zod6.z.string());
+var umdNamedDefine = import_zod6.z.boolean();
+var libraryOptions = import_zod6.z.strictObject({
   amdContainer: amdContainer.optional(),
   auxiliaryComment: auxiliaryComment.optional(),
   export: libraryExport.optional(),
@@ -12036,12 +12324,12 @@ var libraryOptions = import_zod5.z.strictObject({
   umdNamedDefine: umdNamedDefine.optional()
 });
 var library = libraryName.or(libraryOptions).optional();
-var layer = import_zod5.z.string().or(import_zod5.z.null());
+var layer = import_zod6.z.string().or(import_zod6.z.null());
 var entryFilename = filename;
-var entryRuntime = import_zod5.z.literal(false).or(import_zod5.z.string());
-var entryItem = import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string()));
-var entryDependOn = import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string()));
-var entryDescription = import_zod5.z.strictObject({
+var entryRuntime = import_zod6.z.literal(false).or(import_zod6.z.string());
+var entryItem = import_zod6.z.string().or(import_zod6.z.array(import_zod6.z.string()));
+var entryDependOn = import_zod6.z.string().or(import_zod6.z.array(import_zod6.z.string()));
+var entryDescription = import_zod6.z.strictObject({
   import: entryItem,
   runtime: entryRuntime.optional(),
   publicPath: publicPath.optional(),
@@ -12055,90 +12343,90 @@ var entryDescription = import_zod5.z.strictObject({
   layer: layer.optional()
 });
 var entryUnnamed = entryItem;
-var entryObject = import_zod5.z.record(
+var entryObject = import_zod6.z.record(
   entryItem.or(entryDescription)
 );
 var entryStatic = entryObject.or(
   entryUnnamed
 );
-var entryDynamic = import_zod5.z.function().returns(
-  entryStatic.or(import_zod5.z.promise(entryStatic))
+var entryDynamic = import_zod6.z.function().returns(
+  entryStatic.or(import_zod6.z.promise(entryStatic))
 );
 var entry = entryStatic.or(entryDynamic);
-var path9 = import_zod5.z.string();
-var pathinfo = import_zod5.z.boolean().or(import_zod5.z.literal("verbose"));
+var path9 = import_zod6.z.string();
+var pathinfo = import_zod6.z.boolean().or(import_zod6.z.literal("verbose"));
 var assetModuleFilename = filename;
-var webassemblyModuleFilename = import_zod5.z.string();
+var webassemblyModuleFilename = import_zod6.z.string();
 var chunkFilename = filename;
-var crossOriginLoading = import_zod5.z.literal(false).or(
-  import_zod5.z.enum(["anonymous", "use-credentials"])
+var crossOriginLoading = import_zod6.z.literal(false).or(
+  import_zod6.z.enum(["anonymous", "use-credentials"])
 );
 var cssFilename = filename;
 var cssChunkFilename = filename;
 var hotUpdateChunkFilename = filenameTemplate;
 var hotUpdateMainFilename = filenameTemplate;
-var hotUpdateGlobal = import_zod5.z.string();
-var uniqueName = import_zod5.z.string();
-var chunkLoadingGlobal = import_zod5.z.string();
-var enabledLibraryTypes = import_zod5.z.array(
+var hotUpdateGlobal = import_zod6.z.string();
+var uniqueName = import_zod6.z.string();
+var chunkLoadingGlobal = import_zod6.z.string();
+var enabledLibraryTypes = import_zod6.z.array(
   libraryType
 );
-var clean = import_zod5.z.union([
-  import_zod5.z.boolean(),
-  import_zod5.z.strictObject({
-    keep: import_zod5.z.string().optional()
+var clean = import_zod6.z.union([
+  import_zod6.z.boolean(),
+  import_zod6.z.strictObject({
+    keep: import_zod6.z.string().optional()
   })
 ]);
-var outputModule = import_zod5.z.boolean();
-var strictModuleExceptionHandling = import_zod5.z.boolean();
-var strictModuleErrorHandling = import_zod5.z.boolean();
-var globalObject = import_zod5.z.string();
-var enabledWasmLoadingTypes = import_zod5.z.array(
+var outputModule = import_zod6.z.boolean();
+var strictModuleExceptionHandling = import_zod6.z.boolean();
+var strictModuleErrorHandling = import_zod6.z.boolean();
+var globalObject = import_zod6.z.string();
+var enabledWasmLoadingTypes = import_zod6.z.array(
   wasmLoadingType
 );
-var importFunctionName = import_zod5.z.string();
-var importMetaName = import_zod5.z.string();
-var iife = import_zod5.z.boolean();
-var enabledChunkLoadingTypes = import_zod5.z.array(
+var importFunctionName = import_zod6.z.string();
+var importMetaName = import_zod6.z.string();
+var iife = import_zod6.z.boolean();
+var enabledChunkLoadingTypes = import_zod6.z.array(
   chunkLoadingType
 );
-var chunkFormat = import_zod5.z.literal(false).or(import_zod5.z.string());
-var workerPublicPath = import_zod5.z.string();
-var trustedTypes = import_zod5.z.strictObject({
-  policyName: import_zod5.z.string().optional(),
-  onPolicyCreationFailure: import_zod5.z.enum(["continue", "stop"]).optional()
+var chunkFormat = import_zod6.z.literal(false).or(import_zod6.z.string());
+var workerPublicPath = import_zod6.z.string();
+var trustedTypes = import_zod6.z.strictObject({
+  policyName: import_zod6.z.string().optional(),
+  onPolicyCreationFailure: import_zod6.z.enum(["continue", "stop"]).optional()
 });
-var hashDigest = import_zod5.z.string();
-var hashDigestLength = import_zod5.z.number();
-var hashFunction = import_zod5.z.enum([
+var hashDigest = import_zod6.z.string();
+var hashDigestLength = import_zod6.z.number();
+var hashFunction = import_zod6.z.enum([
   "md4",
   "xxhash64"
 ]);
-var hashSalt = import_zod5.z.string();
-var sourceMapFilename = import_zod5.z.string();
-var devtoolNamespace = import_zod5.z.string();
-var devtoolModuleFilenameTemplate = import_zod5.z.union([
-  import_zod5.z.string(),
-  import_zod5.z.function(import_zod5.z.tuple([import_zod5.z.any()]), import_zod5.z.any())
+var hashSalt = import_zod6.z.string();
+var sourceMapFilename = import_zod6.z.string();
+var devtoolNamespace = import_zod6.z.string();
+var devtoolModuleFilenameTemplate = import_zod6.z.union([
+  import_zod6.z.string(),
+  import_zod6.z.function(import_zod6.z.tuple([import_zod6.z.any()]), import_zod6.z.any())
 ]);
 var devtoolFallbackModuleFilenameTemplate = devtoolModuleFilenameTemplate;
-var environment = import_zod5.z.strictObject({
-  arrowFunction: import_zod5.z.boolean().optional(),
-  asyncFunction: import_zod5.z.boolean().optional(),
-  bigIntLiteral: import_zod5.z.boolean().optional(),
-  const: import_zod5.z.boolean().optional(),
-  destructuring: import_zod5.z.boolean().optional(),
-  document: import_zod5.z.boolean().optional(),
-  dynamicImport: import_zod5.z.boolean().optional(),
-  dynamicImportInWorker: import_zod5.z.boolean().optional(),
-  forOf: import_zod5.z.boolean().optional(),
-  globalThis: import_zod5.z.boolean().optional(),
-  module: import_zod5.z.boolean().optional(),
-  nodePrefixForCoreModules: import_zod5.z.boolean().optional(),
-  optionalChaining: import_zod5.z.boolean().optional(),
-  templateLiteral: import_zod5.z.boolean().optional()
+var environment = import_zod6.z.strictObject({
+  arrowFunction: import_zod6.z.boolean().optional(),
+  asyncFunction: import_zod6.z.boolean().optional(),
+  bigIntLiteral: import_zod6.z.boolean().optional(),
+  const: import_zod6.z.boolean().optional(),
+  destructuring: import_zod6.z.boolean().optional(),
+  document: import_zod6.z.boolean().optional(),
+  dynamicImport: import_zod6.z.boolean().optional(),
+  dynamicImportInWorker: import_zod6.z.boolean().optional(),
+  forOf: import_zod6.z.boolean().optional(),
+  globalThis: import_zod6.z.boolean().optional(),
+  module: import_zod6.z.boolean().optional(),
+  nodePrefixForCoreModules: import_zod6.z.boolean().optional(),
+  optionalChaining: import_zod6.z.boolean().optional(),
+  templateLiteral: import_zod6.z.boolean().optional()
 });
-var output = import_zod5.z.strictObject({
+var output = import_zod6.z.strictObject({
   path: path9.optional(),
   pathinfo: pathinfo.optional(),
   clean: clean.optional(),
@@ -12147,7 +12435,7 @@ var output = import_zod5.z.strictObject({
   chunkFilename: chunkFilename.optional(),
   crossOriginLoading: crossOriginLoading.optional(),
   cssFilename: cssFilename.optional(),
-  cssHeadDataCompression: import_zod5.z.boolean().optional(),
+  cssHeadDataCompression: import_zod6.z.boolean().optional(),
   cssChunkFilename: cssChunkFilename.optional(),
   hotUpdateMainFilename: hotUpdateMainFilename.optional(),
   hotUpdateChunkFilename: hotUpdateChunkFilename.optional(),
@@ -12174,7 +12462,7 @@ var output = import_zod5.z.strictObject({
   chunkFormat: chunkFormat.optional(),
   chunkLoading: chunkLoading.optional(),
   enabledChunkLoadingTypes: enabledChunkLoadingTypes.optional(),
-  trustedTypes: import_zod5.z.literal(true).or(import_zod5.z.string()).or(trustedTypes).optional(),
+  trustedTypes: import_zod6.z.literal(true).or(import_zod6.z.string()).or(trustedTypes).optional(),
   sourceMapFilename: sourceMapFilename.optional(),
   hashDigest: hashDigest.optional(),
   hashDigestLength: hashDigestLength.optional(),
@@ -12188,61 +12476,61 @@ var output = import_zod5.z.strictObject({
   devtoolNamespace: devtoolNamespace.optional(),
   devtoolModuleFilenameTemplate: devtoolModuleFilenameTemplate.optional(),
   devtoolFallbackModuleFilenameTemplate: devtoolFallbackModuleFilenameTemplate.optional(),
-  chunkLoadTimeout: import_zod5.z.number().optional(),
-  charset: import_zod5.z.boolean().optional(),
+  chunkLoadTimeout: import_zod6.z.number().optional(),
+  charset: import_zod6.z.boolean().optional(),
   environment: environment.optional(),
-  compareBeforeEmit: import_zod5.z.boolean().optional()
+  compareBeforeEmit: import_zod6.z.boolean().optional()
 });
-var resolveAlias = import_zod5.z.record(
-  import_zod5.z.literal(false).or(import_zod5.z.string()).or(import_zod5.z.array(import_zod5.z.string().or(import_zod5.z.literal(false))))
+var resolveAlias = import_zod6.z.record(
+  import_zod6.z.literal(false).or(import_zod6.z.string()).or(import_zod6.z.array(import_zod6.z.string().or(import_zod6.z.literal(false))))
 );
-var resolveTsConfigFile = import_zod5.z.string();
+var resolveTsConfigFile = import_zod6.z.string();
 var resolveTsConfig = resolveTsConfigFile.or(
-  import_zod5.z.strictObject({
+  import_zod6.z.strictObject({
     configFile: resolveTsConfigFile,
-    references: import_zod5.z.array(import_zod5.z.string()).or(import_zod5.z.literal("auto")).optional()
+    references: import_zod6.z.array(import_zod6.z.string()).or(import_zod6.z.literal("auto")).optional()
   })
 );
-var baseResolveOptions = import_zod5.z.strictObject({
+var baseResolveOptions = import_zod6.z.strictObject({
   alias: resolveAlias.optional(),
-  conditionNames: import_zod5.z.array(import_zod5.z.string()).optional(),
-  extensions: import_zod5.z.array(import_zod5.z.string()).optional(),
+  conditionNames: import_zod6.z.array(import_zod6.z.string()).optional(),
+  extensions: import_zod6.z.array(import_zod6.z.string()).optional(),
   fallback: resolveAlias.optional(),
-  mainFields: import_zod5.z.array(import_zod5.z.string()).optional(),
-  mainFiles: import_zod5.z.array(import_zod5.z.string()).optional(),
-  modules: import_zod5.z.array(import_zod5.z.string()).optional(),
-  preferRelative: import_zod5.z.boolean().optional(),
-  preferAbsolute: import_zod5.z.boolean().optional(),
-  symlinks: import_zod5.z.boolean().optional(),
-  enforceExtension: import_zod5.z.boolean().optional(),
-  importsFields: import_zod5.z.array(import_zod5.z.string()).optional(),
-  descriptionFiles: import_zod5.z.array(import_zod5.z.string()).optional(),
+  mainFields: import_zod6.z.array(import_zod6.z.string()).optional(),
+  mainFiles: import_zod6.z.array(import_zod6.z.string()).optional(),
+  modules: import_zod6.z.array(import_zod6.z.string()).optional(),
+  preferRelative: import_zod6.z.boolean().optional(),
+  preferAbsolute: import_zod6.z.boolean().optional(),
+  symlinks: import_zod6.z.boolean().optional(),
+  enforceExtension: import_zod6.z.boolean().optional(),
+  importsFields: import_zod6.z.array(import_zod6.z.string()).optional(),
+  descriptionFiles: import_zod6.z.array(import_zod6.z.string()).optional(),
   tsConfig: resolveTsConfig.optional(),
-  fullySpecified: import_zod5.z.boolean().optional(),
-  exportsFields: import_zod5.z.array(import_zod5.z.string()).optional(),
-  extensionAlias: import_zod5.z.record(import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string()))).optional(),
-  aliasFields: import_zod5.z.array(import_zod5.z.string()).optional(),
-  restrictions: import_zod5.z.array(import_zod5.z.string()).optional(),
-  roots: import_zod5.z.array(import_zod5.z.string()).optional(),
-  pnp: import_zod5.z.boolean().optional()
+  fullySpecified: import_zod6.z.boolean().optional(),
+  exportsFields: import_zod6.z.array(import_zod6.z.string()).optional(),
+  extensionAlias: import_zod6.z.record(import_zod6.z.string().or(import_zod6.z.array(import_zod6.z.string()))).optional(),
+  aliasFields: import_zod6.z.array(import_zod6.z.string()).optional(),
+  restrictions: import_zod6.z.array(import_zod6.z.string()).optional(),
+  roots: import_zod6.z.array(import_zod6.z.string()).optional(),
+  pnp: import_zod6.z.boolean().optional()
 });
 var resolveOptions = baseResolveOptions.extend({
-  byDependency: import_zod5.z.lazy(() => import_zod5.z.record(resolveOptions)).optional()
+  byDependency: import_zod6.z.lazy(() => import_zod6.z.record(resolveOptions)).optional()
 });
-var baseRuleSetCondition = import_zod5.z.instanceof(RegExp).or(import_zod5.z.string()).or(import_zod5.z.function().args(import_zod5.z.string()).returns(import_zod5.z.boolean()));
-var ruleSetCondition = baseRuleSetCondition.or(import_zod5.z.lazy(() => ruleSetConditions)).or(import_zod5.z.lazy(() => ruleSetLogicalConditions));
-var ruleSetConditions = import_zod5.z.lazy(
-  () => import_zod5.z.array(ruleSetCondition)
+var baseRuleSetCondition = import_zod6.z.instanceof(RegExp).or(import_zod6.z.string()).or(import_zod6.z.function().args(import_zod6.z.string()).returns(import_zod6.z.boolean()));
+var ruleSetCondition = baseRuleSetCondition.or(import_zod6.z.lazy(() => ruleSetConditions)).or(import_zod6.z.lazy(() => ruleSetLogicalConditions));
+var ruleSetConditions = import_zod6.z.lazy(
+  () => import_zod6.z.array(ruleSetCondition)
 );
-var ruleSetLogicalConditions = import_zod5.z.strictObject({
+var ruleSetLogicalConditions = import_zod6.z.strictObject({
   and: ruleSetConditions.optional(),
   or: ruleSetConditions.optional(),
   not: ruleSetCondition.optional()
 });
-var ruleSetLoader = import_zod5.z.string();
-var ruleSetLoaderOptions = import_zod5.z.string().or(import_zod5.z.record(import_zod5.z.any()));
-var ruleSetLoaderWithOptions = import_zod5.z.strictObject({
-  ident: import_zod5.z.string().optional(),
+var ruleSetLoader = import_zod6.z.string();
+var ruleSetLoaderOptions = import_zod6.z.string().or(import_zod6.z.record(import_zod6.z.any()));
+var ruleSetLoaderWithOptions = import_zod6.z.strictObject({
+  ident: import_zod6.z.string().optional(),
   loader: ruleSetLoader,
   options: ruleSetLoaderOptions.optional()
 });
@@ -12250,9 +12538,9 @@ var ruleSetUseItem = ruleSetLoader.or(
   ruleSetLoaderWithOptions
 );
 var ruleSetUse = ruleSetUseItem.or(ruleSetUseItem.array()).or(
-  import_zod5.z.function().args(import_zod5.z.custom()).returns(ruleSetUseItem.array())
+  import_zod6.z.function().args(import_zod6.z.custom()).returns(ruleSetUseItem.array())
 );
-var baseRuleSetRule = import_zod5.z.strictObject({
+var baseRuleSetRule = import_zod6.z.strictObject({
   test: ruleSetCondition.optional(),
   exclude: ruleSetCondition.optional(),
   include: ruleSetCondition.optional(),
@@ -12264,67 +12552,67 @@ var baseRuleSetRule = import_zod5.z.strictObject({
   resourceQuery: ruleSetCondition.optional(),
   scheme: ruleSetCondition.optional(),
   mimetype: ruleSetCondition.optional(),
-  descriptionData: import_zod5.z.record(ruleSetCondition).optional(),
-  with: import_zod5.z.record(ruleSetCondition).optional(),
-  type: import_zod5.z.string().optional(),
-  layer: import_zod5.z.string().optional(),
+  descriptionData: import_zod6.z.record(ruleSetCondition).optional(),
+  with: import_zod6.z.record(ruleSetCondition).optional(),
+  type: import_zod6.z.string().optional(),
+  layer: import_zod6.z.string().optional(),
   loader: ruleSetLoader.optional(),
   options: ruleSetLoaderOptions.optional(),
   use: ruleSetUse.optional(),
-  parser: import_zod5.z.record(import_zod5.z.any()).optional(),
-  generator: import_zod5.z.record(import_zod5.z.any()).optional(),
+  parser: import_zod6.z.record(import_zod6.z.any()).optional(),
+  generator: import_zod6.z.record(import_zod6.z.any()).optional(),
   resolve: resolveOptions.optional(),
-  sideEffects: import_zod5.z.boolean().optional(),
-  enforce: import_zod5.z.literal("pre").or(import_zod5.z.literal("post")).optional()
+  sideEffects: import_zod6.z.boolean().optional(),
+  enforce: import_zod6.z.literal("pre").or(import_zod6.z.literal("post")).optional()
 });
 var ruleSetRule = baseRuleSetRule.extend({
-  oneOf: import_zod5.z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
-  rules: import_zod5.z.lazy(() => ruleSetRule.or(falsy).array()).optional()
+  oneOf: import_zod6.z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
+  rules: import_zod6.z.lazy(() => ruleSetRule.or(falsy).array()).optional()
 });
-var ruleSetRules = import_zod5.z.array(
-  import_zod5.z.literal("...").or(ruleSetRule).or(falsy)
+var ruleSetRules = import_zod6.z.array(
+  import_zod6.z.literal("...").or(ruleSetRule).or(falsy)
 );
-var assetParserDataUrlOptions = import_zod5.z.strictObject({
-  maxSize: import_zod5.z.number().optional()
+var assetParserDataUrlOptions = import_zod6.z.strictObject({
+  maxSize: import_zod6.z.number().optional()
 });
 var assetParserDataUrl = assetParserDataUrlOptions;
-var assetParserOptions = import_zod5.z.strictObject({
+var assetParserOptions = import_zod6.z.strictObject({
   dataUrlCondition: assetParserDataUrl.optional()
 });
-var cssParserNamedExports = import_zod5.z.boolean();
-var cssParserOptions = import_zod5.z.strictObject({
+var cssParserNamedExports = import_zod6.z.boolean();
+var cssParserOptions = import_zod6.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var cssAutoParserOptions = import_zod5.z.strictObject({
+var cssAutoParserOptions = import_zod6.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var cssModuleParserOptions = import_zod5.z.strictObject({
+var cssModuleParserOptions = import_zod6.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var dynamicImportMode = import_zod5.z.enum(["eager", "lazy", "weak", "lazy-once"]);
-var dynamicImportPreload = import_zod5.z.union([import_zod5.z.boolean(), import_zod5.z.number()]);
-var dynamicImportPrefetch = import_zod5.z.union([import_zod5.z.boolean(), import_zod5.z.number()]);
-var dynamicImportFetchPriority = import_zod5.z.enum(["low", "high", "auto"]);
-var javascriptParserUrl = import_zod5.z.union([import_zod5.z.literal("relative"), import_zod5.z.boolean()]);
-var exprContextCritical = import_zod5.z.boolean();
-var wrappedContextCritical = import_zod5.z.boolean();
-var wrappedContextRegExp = import_zod5.z.instanceof(RegExp);
-var exportsPresence = import_zod5.z.enum(["error", "warn", "auto"]).or(import_zod5.z.literal(false));
-var importExportsPresence = import_zod5.z.enum(["error", "warn", "auto"]).or(import_zod5.z.literal(false));
-var reexportExportsPresence = import_zod5.z.enum(["error", "warn", "auto"]).or(import_zod5.z.literal(false));
-var strictExportPresence = import_zod5.z.boolean();
-var worker = import_zod5.z.array(import_zod5.z.string()).or(import_zod5.z.boolean());
-var overrideStrict = import_zod5.z.enum(["strict", "non-strict"]);
-var requireAsExpression = import_zod5.z.boolean();
-var requireDynamic = import_zod5.z.boolean();
-var requireResolve = import_zod5.z.boolean();
-var importDynamic = import_zod5.z.boolean();
-var javascriptParserOptions = import_zod5.z.strictObject({
+var dynamicImportMode = import_zod6.z.enum(["eager", "lazy", "weak", "lazy-once"]);
+var dynamicImportPreload = import_zod6.z.union([import_zod6.z.boolean(), import_zod6.z.number()]);
+var dynamicImportPrefetch = import_zod6.z.union([import_zod6.z.boolean(), import_zod6.z.number()]);
+var dynamicImportFetchPriority = import_zod6.z.enum(["low", "high", "auto"]);
+var javascriptParserUrl = import_zod6.z.union([import_zod6.z.literal("relative"), import_zod6.z.boolean()]);
+var exprContextCritical = import_zod6.z.boolean();
+var wrappedContextCritical = import_zod6.z.boolean();
+var wrappedContextRegExp = import_zod6.z.instanceof(RegExp);
+var exportsPresence = import_zod6.z.enum(["error", "warn", "auto"]).or(import_zod6.z.literal(false));
+var importExportsPresence = import_zod6.z.enum(["error", "warn", "auto"]).or(import_zod6.z.literal(false));
+var reexportExportsPresence = import_zod6.z.enum(["error", "warn", "auto"]).or(import_zod6.z.literal(false));
+var strictExportPresence = import_zod6.z.boolean();
+var worker = import_zod6.z.array(import_zod6.z.string()).or(import_zod6.z.boolean());
+var overrideStrict = import_zod6.z.enum(["strict", "non-strict"]);
+var requireAsExpression = import_zod6.z.boolean();
+var requireDynamic = import_zod6.z.boolean();
+var requireResolve = import_zod6.z.boolean();
+var importDynamic = import_zod6.z.boolean();
+var javascriptParserOptions = import_zod6.z.strictObject({
   dynamicImportMode: dynamicImportMode.optional(),
   dynamicImportPreload: dynamicImportPreload.optional(),
   dynamicImportPrefetch: dynamicImportPrefetch.optional(),
   dynamicImportFetchPriority: dynamicImportFetchPriority.optional(),
-  importMeta: import_zod5.z.boolean().optional(),
+  importMeta: import_zod6.z.boolean().optional(),
   url: javascriptParserUrl.optional(),
   exprContextCritical: exprContextCritical.optional(),
   wrappedContextCritical: wrappedContextCritical.optional(),
@@ -12342,7 +12630,7 @@ var javascriptParserOptions = import_zod5.z.strictObject({
   importDynamic: importDynamic.optional()
   // #endregion
 });
-var parserOptionsByModuleTypeKnown = import_zod5.z.strictObject({
+var parserOptionsByModuleTypeKnown = import_zod6.z.strictObject({
   asset: assetParserOptions.optional(),
   css: cssParserOptions.optional(),
   "css/auto": cssAutoParserOptions.optional(),
@@ -12352,64 +12640,64 @@ var parserOptionsByModuleTypeKnown = import_zod5.z.strictObject({
   "javascript/dynamic": javascriptParserOptions.optional(),
   "javascript/esm": javascriptParserOptions.optional()
 });
-var parserOptionsByModuleTypeUnknown = import_zod5.z.record(
-  import_zod5.z.record(import_zod5.z.any())
+var parserOptionsByModuleTypeUnknown = import_zod6.z.record(
+  import_zod6.z.record(import_zod6.z.any())
 );
 var parserOptionsByModuleType = parserOptionsByModuleTypeKnown.or(
   parserOptionsByModuleTypeUnknown
 );
-var assetGeneratorDataUrlOptions = import_zod5.z.strictObject({
-  encoding: import_zod5.z.literal(false).or(import_zod5.z.literal("base64")).optional(),
-  mimetype: import_zod5.z.string().optional()
+var assetGeneratorDataUrlOptions = import_zod6.z.strictObject({
+  encoding: import_zod6.z.literal(false).or(import_zod6.z.literal("base64")).optional(),
+  mimetype: import_zod6.z.string().optional()
 });
-var assetGeneratorDataUrlFunction = import_zod5.z.function().args(
-  import_zod5.z.instanceof(Buffer),
-  import_zod5.z.strictObject({
-    filename: import_zod5.z.string(),
-    module: import_zod5.z.custom()
+var assetGeneratorDataUrlFunction = import_zod6.z.function().args(
+  import_zod6.z.instanceof(Buffer),
+  import_zod6.z.strictObject({
+    filename: import_zod6.z.string(),
+    module: import_zod6.z.custom()
   })
-).returns(import_zod5.z.string());
+).returns(import_zod6.z.string());
 var assetGeneratorDataUrl = assetGeneratorDataUrlOptions.or(
   assetGeneratorDataUrlFunction
 );
-var assetInlineGeneratorOptions = import_zod5.z.strictObject({
+var assetInlineGeneratorOptions = import_zod6.z.strictObject({
   dataUrl: assetGeneratorDataUrl.optional()
 });
-var assetResourceGeneratorOptions = import_zod5.z.strictObject({
-  emit: import_zod5.z.boolean().optional(),
+var assetResourceGeneratorOptions = import_zod6.z.strictObject({
+  emit: import_zod6.z.boolean().optional(),
   filename: filename.optional(),
   publicPath: publicPath.optional()
 });
 var assetGeneratorOptions = assetInlineGeneratorOptions.merge(
   assetResourceGeneratorOptions
 );
-var cssGeneratorExportsConvention = import_zod5.z.enum([
+var cssGeneratorExportsConvention = import_zod6.z.enum([
   "as-is",
   "camel-case",
   "camel-case-only",
   "dashes",
   "dashes-only"
 ]);
-var cssGeneratorExportsOnly = import_zod5.z.boolean();
-var cssGeneratorLocalIdentName = import_zod5.z.string();
-var cssGeneratorEsModule = import_zod5.z.boolean();
-var cssGeneratorOptions = import_zod5.z.strictObject({
+var cssGeneratorExportsOnly = import_zod6.z.boolean();
+var cssGeneratorLocalIdentName = import_zod6.z.string();
+var cssGeneratorEsModule = import_zod6.z.boolean();
+var cssGeneratorOptions = import_zod6.z.strictObject({
   exportsOnly: cssGeneratorExportsOnly.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var cssAutoGeneratorOptions = import_zod5.z.strictObject({
+var cssAutoGeneratorOptions = import_zod6.z.strictObject({
   exportsConvention: cssGeneratorExportsConvention.optional(),
   exportsOnly: cssGeneratorExportsOnly.optional(),
   localIdentName: cssGeneratorLocalIdentName.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var cssModuleGeneratorOptions = import_zod5.z.strictObject({
+var cssModuleGeneratorOptions = import_zod6.z.strictObject({
   exportsConvention: cssGeneratorExportsConvention.optional(),
   exportsOnly: cssGeneratorExportsOnly.optional(),
   localIdentName: cssGeneratorLocalIdentName.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var generatorOptionsByModuleTypeKnown = import_zod5.z.strictObject({
+var generatorOptionsByModuleTypeKnown = import_zod6.z.strictObject({
   asset: assetGeneratorOptions.optional(),
   "asset/inline": assetInlineGeneratorOptions.optional(),
   "asset/resource": assetResourceGeneratorOptions.optional(),
@@ -12417,25 +12705,25 @@ var generatorOptionsByModuleTypeKnown = import_zod5.z.strictObject({
   "css/auto": cssAutoGeneratorOptions.optional(),
   "css/module": cssModuleGeneratorOptions.optional()
 });
-var generatorOptionsByModuleTypeUnknown = import_zod5.z.record(
-  import_zod5.z.record(import_zod5.z.any())
+var generatorOptionsByModuleTypeUnknown = import_zod6.z.record(
+  import_zod6.z.record(import_zod6.z.any())
 );
 var generatorOptionsByModuleType = generatorOptionsByModuleTypeKnown.or(
   generatorOptionsByModuleTypeUnknown
 );
-var noParseOptionSingle = import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).or(import_zod5.z.function().args(import_zod5.z.string()).returns(import_zod5.z.boolean()));
+var noParseOptionSingle = import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).or(import_zod6.z.function().args(import_zod6.z.string()).returns(import_zod6.z.boolean()));
 var noParseOption = noParseOptionSingle.or(
-  import_zod5.z.array(noParseOptionSingle)
+  import_zod6.z.array(noParseOptionSingle)
 );
-var moduleOptions = import_zod5.z.strictObject({
+var moduleOptions = import_zod6.z.strictObject({
   defaultRules: ruleSetRules.optional(),
   rules: ruleSetRules.optional(),
   parser: parserOptionsByModuleType.optional(),
   generator: generatorOptionsByModuleType.optional(),
   noParse: noParseOption.optional()
 });
-var allowTarget = import_zod5.z.union([
-  import_zod5.z.enum([
+var allowTarget = import_zod6.z.union([
+  import_zod6.z.enum([
     "web",
     "webworker",
     "es3",
@@ -12449,66 +12737,66 @@ var allowTarget = import_zod5.z.union([
     "es2021",
     "es2022"
   ]),
-  import_zod5.z.literal("node"),
-  import_zod5.z.literal("async-node"),
-  import_zod5.z.custom(
+  import_zod6.z.literal("node"),
+  import_zod6.z.literal("async-node"),
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^node\d+$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^async-node\d+$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^node\d+\.\d+$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^async-node\d+\.\d+$/.test(value)
   ),
-  import_zod5.z.literal("electron-main"),
-  import_zod5.z.custom(
+  import_zod6.z.literal("electron-main"),
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^electron\d+-main$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-main$/.test(value)
   ),
-  import_zod5.z.literal("electron-renderer"),
-  import_zod5.z.custom(
+  import_zod6.z.literal("electron-renderer"),
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^electron\d+-renderer$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-renderer$/.test(value)
   ),
-  import_zod5.z.literal("electron-preload"),
-  import_zod5.z.custom(
+  import_zod6.z.literal("electron-preload"),
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^electron\d+-preload$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-preload$/.test(value)
   ),
-  import_zod5.z.literal("nwjs"),
-  import_zod5.z.custom(
+  import_zod6.z.literal("nwjs"),
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^nwjs\d+$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^nwjs\d+\.\d+$/.test(value)
   ),
-  import_zod5.z.literal("node-webkit"),
-  import_zod5.z.custom(
+  import_zod6.z.literal("node-webkit"),
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^node-webkit\d+$/.test(value)
   ),
-  import_zod5.z.custom(
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^node-webkit\d+\.\d+$/.test(value)
   ),
-  import_zod5.z.literal("browserslist"),
-  import_zod5.z.custom(
+  import_zod6.z.literal("browserslist"),
+  import_zod6.z.custom(
     (value) => typeof value === "string" && /^browserslist:(.+)$/.test(value)
   )
 ]);
-var target = import_zod5.z.union([
-  import_zod5.z.literal(false),
+var target = import_zod6.z.union([
+  import_zod6.z.literal(false),
   allowTarget,
   allowTarget.array()
 ]);
-var externalsType = import_zod5.z.enum([
+var externalsType = import_zod6.z.enum([
   "var",
   "module",
   "assign",
@@ -12550,18 +12838,18 @@ var ZodExternalObjectValue = new ZodRspackCrossChecker({
         }
         return false;
       },
-      type: import_zod5.z.strictObject({
-        root: import_zod5.z.string().or(import_zod5.z.string().array()),
-        commonjs: import_zod5.z.string().or(import_zod5.z.string().array()),
-        commonjs2: import_zod5.z.string().or(import_zod5.z.string().array()),
-        amd: import_zod5.z.string().or(import_zod5.z.string().array())
+      type: import_zod6.z.strictObject({
+        root: import_zod6.z.string().or(import_zod6.z.string().array()),
+        commonjs: import_zod6.z.string().or(import_zod6.z.string().array()),
+        commonjs2: import_zod6.z.string().or(import_zod6.z.string().array()),
+        amd: import_zod6.z.string().or(import_zod6.z.string().array())
       }),
       issue: (res) => {
         if (res.status === "aborted") {
           return [
             {
               fatal: true,
-              code: import_zod5.ZodIssueCode.custom,
+              code: import_zod6.ZodIssueCode.custom,
               message: `External object must have "root", "commonjs", "commonjs2", "amd" properties when "libraryType" or "externalsType" is "umd"`
             }
           ];
@@ -12570,69 +12858,69 @@ var ZodExternalObjectValue = new ZodRspackCrossChecker({
       }
     }
   ],
-  default: import_zod5.z.record(import_zod5.z.string().or(import_zod5.z.string().array()))
+  default: import_zod6.z.record(import_zod6.z.string().or(import_zod6.z.string().array()))
 });
-var externalItemValue = import_zod5.z.string().or(import_zod5.z.boolean()).or(import_zod5.z.string().array().min(1)).or(ZodExternalObjectValue);
-var externalItemObjectUnknown = import_zod5.z.record(
+var externalItemValue = import_zod6.z.string().or(import_zod6.z.boolean()).or(import_zod6.z.string().array().min(1)).or(ZodExternalObjectValue);
+var externalItemObjectUnknown = import_zod6.z.record(
   externalItemValue
 );
-var externalItemFunctionData = import_zod5.z.strictObject({
-  context: import_zod5.z.string().optional(),
-  dependencyType: import_zod5.z.string().optional(),
-  request: import_zod5.z.string().optional(),
-  contextInfo: import_zod5.z.strictObject({
-    issuer: import_zod5.z.string(),
-    issuerLayer: import_zod5.z.string().or(import_zod5.z.null()).optional()
+var externalItemFunctionData = import_zod6.z.strictObject({
+  context: import_zod6.z.string().optional(),
+  dependencyType: import_zod6.z.string().optional(),
+  request: import_zod6.z.string().optional(),
+  contextInfo: import_zod6.z.strictObject({
+    issuer: import_zod6.z.string(),
+    issuerLayer: import_zod6.z.string().or(import_zod6.z.null()).optional()
   }).optional(),
-  getResolve: import_zod5.z.function().returns(
-    import_zod5.z.function().args(import_zod5.z.string(), import_zod5.z.string()).returns(import_zod5.z.promise(import_zod5.z.string())).or(
-      import_zod5.z.function().args(
-        import_zod5.z.string(),
-        import_zod5.z.string(),
-        import_zod5.z.function().args(import_zod5.z.instanceof(Error).optional(), import_zod5.z.string().optional()).returns(import_zod5.z.void())
-      ).returns(import_zod5.z.void())
+  getResolve: import_zod6.z.function().returns(
+    import_zod6.z.function().args(import_zod6.z.string(), import_zod6.z.string()).returns(import_zod6.z.promise(import_zod6.z.string())).or(
+      import_zod6.z.function().args(
+        import_zod6.z.string(),
+        import_zod6.z.string(),
+        import_zod6.z.function().args(import_zod6.z.instanceof(Error).optional(), import_zod6.z.string().optional()).returns(import_zod6.z.void())
+      ).returns(import_zod6.z.void())
     )
   ).optional()
 });
-var externalItem = import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).or(externalItemObjectUnknown).or(
-  import_zod5.z.function().args(
+var externalItem = import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).or(externalItemObjectUnknown).or(
+  import_zod6.z.function().args(
     externalItemFunctionData,
-    import_zod5.z.function().args(
-      import_zod5.z.instanceof(Error).optional(),
+    import_zod6.z.function().args(
+      import_zod6.z.instanceof(Error).optional(),
       externalItemValue.optional(),
       externalsType.optional()
-    ).returns(import_zod5.z.void())
+    ).returns(import_zod6.z.void())
   )
 ).or(
-  import_zod5.z.function().args(externalItemFunctionData).returns(import_zod5.z.promise(externalItemValue))
+  import_zod6.z.function().args(externalItemFunctionData).returns(import_zod6.z.promise(externalItemValue))
 ).or(
-  import_zod5.z.function().args(externalItemFunctionData).returns(externalItemValue)
+  import_zod6.z.function().args(externalItemFunctionData).returns(externalItemValue)
 );
 var externals = externalItem.array().or(externalItem);
-var externalsPresets = import_zod5.z.strictObject({
-  node: import_zod5.z.boolean().optional(),
-  web: import_zod5.z.boolean().optional(),
-  webAsync: import_zod5.z.boolean().optional(),
-  electron: import_zod5.z.boolean().optional(),
-  electronMain: import_zod5.z.boolean().optional(),
-  electronPreload: import_zod5.z.boolean().optional(),
-  electronRenderer: import_zod5.z.boolean().optional(),
-  nwjs: import_zod5.z.boolean().optional()
+var externalsPresets = import_zod6.z.strictObject({
+  node: import_zod6.z.boolean().optional(),
+  web: import_zod6.z.boolean().optional(),
+  webAsync: import_zod6.z.boolean().optional(),
+  electron: import_zod6.z.boolean().optional(),
+  electronMain: import_zod6.z.boolean().optional(),
+  electronPreload: import_zod6.z.boolean().optional(),
+  electronRenderer: import_zod6.z.boolean().optional(),
+  nwjs: import_zod6.z.boolean().optional()
 });
-var filterItemTypes = import_zod5.z.instanceof(RegExp).or(import_zod5.z.string()).or(
-  import_zod5.z.function().args(import_zod5.z.string()).returns(import_zod5.z.boolean())
+var filterItemTypes = import_zod6.z.instanceof(RegExp).or(import_zod6.z.string()).or(
+  import_zod6.z.function().args(import_zod6.z.string()).returns(import_zod6.z.boolean())
 );
 var filterTypes = filterItemTypes.array().or(filterItemTypes);
-var infrastructureLogging = import_zod5.z.strictObject({
-  appendOnly: import_zod5.z.boolean().optional(),
-  colors: import_zod5.z.boolean().optional(),
-  console: import_zod5.z.custom().optional(),
-  debug: import_zod5.z.boolean().or(filterTypes).optional(),
-  level: import_zod5.z.enum(["none", "error", "warn", "info", "log", "verbose"]).optional(),
-  stream: import_zod5.z.custom().optional()
+var infrastructureLogging = import_zod6.z.strictObject({
+  appendOnly: import_zod6.z.boolean().optional(),
+  colors: import_zod6.z.boolean().optional(),
+  console: import_zod6.z.custom().optional(),
+  debug: import_zod6.z.boolean().or(filterTypes).optional(),
+  level: import_zod6.z.enum(["none", "error", "warn", "info", "log", "verbose"]).optional(),
+  stream: import_zod6.z.custom().optional()
 });
-var devTool = import_zod5.z.literal(false).or(
-  import_zod5.z.enum([
+var devTool = import_zod6.z.literal(false).or(
+  import_zod6.z.enum([
     "eval",
     "cheap-source-map",
     "cheap-module-source-map",
@@ -12660,18 +12948,18 @@ var devTool = import_zod5.z.literal(false).or(
     "eval-nosources-source-map"
   ])
 );
-var nodeOptions = import_zod5.z.strictObject({
-  __dirname: import_zod5.z.boolean().or(import_zod5.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
-  __filename: import_zod5.z.boolean().or(import_zod5.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
-  global: import_zod5.z.boolean().or(import_zod5.z.literal("warn")).optional()
+var nodeOptions = import_zod6.z.strictObject({
+  __dirname: import_zod6.z.boolean().or(import_zod6.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
+  __filename: import_zod6.z.boolean().or(import_zod6.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
+  global: import_zod6.z.boolean().or(import_zod6.z.literal("warn")).optional()
 });
-var node = import_zod5.z.literal(false).or(nodeOptions);
-var loader = import_zod5.z.record(import_zod5.z.string(), import_zod5.z.any());
-var snapshotOptions = import_zod5.z.strictObject(
+var node = import_zod6.z.literal(false).or(nodeOptions);
+var loader = import_zod6.z.record(import_zod6.z.string(), import_zod6.z.any());
+var snapshotOptions = import_zod6.z.strictObject(
   {}
 );
-var cacheOptions = import_zod5.z.boolean();
-var statsPresets = import_zod5.z.enum([
+var cacheOptions = import_zod6.z.boolean();
+var statsPresets = import_zod6.z.enum([
   "normal",
   "none",
   "verbose",
@@ -12681,272 +12969,275 @@ var statsPresets = import_zod5.z.enum([
   "detailed",
   "summary"
 ]);
-var statsOptions = import_zod5.z.strictObject({
-  all: import_zod5.z.boolean().optional(),
-  preset: import_zod5.z.boolean().or(statsPresets).optional(),
-  assets: import_zod5.z.boolean().optional(),
-  chunks: import_zod5.z.boolean().optional(),
-  modules: import_zod5.z.boolean().optional(),
-  entrypoints: import_zod5.z.boolean().or(import_zod5.z.literal("auto")).optional(),
-  chunkGroups: import_zod5.z.boolean().optional(),
-  warnings: import_zod5.z.boolean().optional(),
-  warningsCount: import_zod5.z.boolean().optional(),
-  errors: import_zod5.z.boolean().optional(),
-  errorsCount: import_zod5.z.boolean().optional(),
-  colors: import_zod5.z.boolean().optional(),
-  hash: import_zod5.z.boolean().optional(),
-  version: import_zod5.z.boolean().optional(),
-  reasons: import_zod5.z.boolean().optional(),
-  publicPath: import_zod5.z.boolean().optional(),
-  outputPath: import_zod5.z.boolean().optional(),
-  chunkModules: import_zod5.z.boolean().optional(),
-  chunkRelations: import_zod5.z.boolean().optional(),
-  ids: import_zod5.z.boolean().optional(),
-  timings: import_zod5.z.boolean().optional(),
-  builtAt: import_zod5.z.boolean().optional(),
-  moduleAssets: import_zod5.z.boolean().optional(),
-  nestedModules: import_zod5.z.boolean().optional(),
-  source: import_zod5.z.boolean().optional(),
-  logging: import_zod5.z.enum(["none", "error", "warn", "info", "log", "verbose"]).or(import_zod5.z.boolean()).optional(),
-  loggingDebug: import_zod5.z.boolean().or(filterTypes).optional(),
-  loggingTrace: import_zod5.z.boolean().optional(),
-  runtimeModules: import_zod5.z.boolean().optional(),
-  children: import_zod5.z.boolean().optional(),
-  usedExports: import_zod5.z.boolean().optional(),
-  providedExports: import_zod5.z.boolean().optional(),
-  optimizationBailout: import_zod5.z.boolean().optional(),
-  groupModulesByType: import_zod5.z.boolean().optional(),
-  groupModulesByCacheStatus: import_zod5.z.boolean().optional(),
-  groupModulesByLayer: import_zod5.z.boolean().optional(),
-  groupModulesByAttributes: import_zod5.z.boolean().optional(),
-  groupModulesByPath: import_zod5.z.boolean().optional(),
-  groupModulesByExtension: import_zod5.z.boolean().optional(),
-  modulesSpace: import_zod5.z.number().optional(),
-  chunkModulesSpace: import_zod5.z.number().optional(),
-  nestedModulesSpace: import_zod5.z.number().optional(),
-  relatedAssets: import_zod5.z.boolean().optional(),
-  groupAssetsByEmitStatus: import_zod5.z.boolean().optional(),
-  groupAssetsByInfo: import_zod5.z.boolean().optional(),
-  groupAssetsByPath: import_zod5.z.boolean().optional(),
-  groupAssetsByExtension: import_zod5.z.boolean().optional(),
-  groupAssetsByChunk: import_zod5.z.boolean().optional(),
-  assetsSpace: import_zod5.z.number().optional(),
-  orphanModules: import_zod5.z.boolean().optional(),
-  excludeModules: import_zod5.z.array(
-    import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).or(import_zod5.z.function(import_zod5.z.tuple([import_zod5.z.string(), import_zod5.z.any(), import_zod5.z.any()]), import_zod5.z.boolean()))
-  ).or(import_zod5.z.string()).or(import_zod5.z.instanceof(RegExp)).or(import_zod5.z.function(import_zod5.z.tuple([import_zod5.z.string(), import_zod5.z.any(), import_zod5.z.any()]), import_zod5.z.boolean())).or(import_zod5.z.boolean()).optional(),
-  excludeAssets: import_zod5.z.array(
-    import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).or(import_zod5.z.function(import_zod5.z.tuple([import_zod5.z.string(), import_zod5.z.any()]), import_zod5.z.boolean()))
-  ).or(import_zod5.z.string()).or(import_zod5.z.instanceof(RegExp)).or(import_zod5.z.function(import_zod5.z.tuple([import_zod5.z.string(), import_zod5.z.any()]), import_zod5.z.boolean())).optional(),
-  modulesSort: import_zod5.z.string().optional(),
-  chunkModulesSort: import_zod5.z.string().optional(),
-  nestedModulesSort: import_zod5.z.string().optional(),
-  chunksSort: import_zod5.z.string().optional(),
-  assetsSort: import_zod5.z.string().optional(),
-  performance: import_zod5.z.boolean().optional(),
-  env: import_zod5.z.boolean().optional(),
-  chunkGroupAuxiliary: import_zod5.z.boolean().optional(),
-  chunkGroupChildren: import_zod5.z.boolean().optional(),
-  chunkGroupMaxAssets: import_zod5.z.number().optional(),
-  dependentModules: import_zod5.z.boolean().optional(),
-  chunkOrigins: import_zod5.z.boolean().optional(),
-  runtime: import_zod5.z.boolean().optional(),
-  depth: import_zod5.z.boolean().optional(),
-  reasonsSpace: import_zod5.z.number().optional(),
-  groupReasonsByOrigin: import_zod5.z.boolean().optional(),
-  errorDetails: import_zod5.z.boolean().optional(),
-  errorStack: import_zod5.z.boolean().optional(),
-  moduleTrace: import_zod5.z.boolean().optional(),
-  cachedModules: import_zod5.z.boolean().optional(),
-  cachedAssets: import_zod5.z.boolean().optional(),
-  cached: import_zod5.z.boolean().optional(),
-  errorsSpace: import_zod5.z.number().optional(),
-  warningsSpace: import_zod5.z.number().optional()
+var statsOptions = import_zod6.z.strictObject({
+  all: import_zod6.z.boolean().optional(),
+  preset: import_zod6.z.boolean().or(statsPresets).optional(),
+  assets: import_zod6.z.boolean().optional(),
+  chunks: import_zod6.z.boolean().optional(),
+  modules: import_zod6.z.boolean().optional(),
+  entrypoints: import_zod6.z.boolean().or(import_zod6.z.literal("auto")).optional(),
+  chunkGroups: import_zod6.z.boolean().optional(),
+  warnings: import_zod6.z.boolean().optional(),
+  warningsCount: import_zod6.z.boolean().optional(),
+  errors: import_zod6.z.boolean().optional(),
+  errorsCount: import_zod6.z.boolean().optional(),
+  colors: import_zod6.z.boolean().optional(),
+  hash: import_zod6.z.boolean().optional(),
+  version: import_zod6.z.boolean().optional(),
+  reasons: import_zod6.z.boolean().optional(),
+  publicPath: import_zod6.z.boolean().optional(),
+  outputPath: import_zod6.z.boolean().optional(),
+  chunkModules: import_zod6.z.boolean().optional(),
+  chunkRelations: import_zod6.z.boolean().optional(),
+  ids: import_zod6.z.boolean().optional(),
+  timings: import_zod6.z.boolean().optional(),
+  builtAt: import_zod6.z.boolean().optional(),
+  moduleAssets: import_zod6.z.boolean().optional(),
+  nestedModules: import_zod6.z.boolean().optional(),
+  source: import_zod6.z.boolean().optional(),
+  logging: import_zod6.z.enum(["none", "error", "warn", "info", "log", "verbose"]).or(import_zod6.z.boolean()).optional(),
+  loggingDebug: import_zod6.z.boolean().or(filterTypes).optional(),
+  loggingTrace: import_zod6.z.boolean().optional(),
+  runtimeModules: import_zod6.z.boolean().optional(),
+  children: import_zod6.z.boolean().optional(),
+  usedExports: import_zod6.z.boolean().optional(),
+  providedExports: import_zod6.z.boolean().optional(),
+  optimizationBailout: import_zod6.z.boolean().optional(),
+  groupModulesByType: import_zod6.z.boolean().optional(),
+  groupModulesByCacheStatus: import_zod6.z.boolean().optional(),
+  groupModulesByLayer: import_zod6.z.boolean().optional(),
+  groupModulesByAttributes: import_zod6.z.boolean().optional(),
+  groupModulesByPath: import_zod6.z.boolean().optional(),
+  groupModulesByExtension: import_zod6.z.boolean().optional(),
+  modulesSpace: import_zod6.z.number().optional(),
+  chunkModulesSpace: import_zod6.z.number().optional(),
+  nestedModulesSpace: import_zod6.z.number().optional(),
+  relatedAssets: import_zod6.z.boolean().optional(),
+  groupAssetsByEmitStatus: import_zod6.z.boolean().optional(),
+  groupAssetsByInfo: import_zod6.z.boolean().optional(),
+  groupAssetsByPath: import_zod6.z.boolean().optional(),
+  groupAssetsByExtension: import_zod6.z.boolean().optional(),
+  groupAssetsByChunk: import_zod6.z.boolean().optional(),
+  assetsSpace: import_zod6.z.number().optional(),
+  orphanModules: import_zod6.z.boolean().optional(),
+  excludeModules: import_zod6.z.array(
+    import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).or(import_zod6.z.function(import_zod6.z.tuple([import_zod6.z.string(), import_zod6.z.any(), import_zod6.z.any()]), import_zod6.z.boolean()))
+  ).or(import_zod6.z.string()).or(import_zod6.z.instanceof(RegExp)).or(import_zod6.z.function(import_zod6.z.tuple([import_zod6.z.string(), import_zod6.z.any(), import_zod6.z.any()]), import_zod6.z.boolean())).or(import_zod6.z.boolean()).optional(),
+  excludeAssets: import_zod6.z.array(
+    import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).or(import_zod6.z.function(import_zod6.z.tuple([import_zod6.z.string(), import_zod6.z.any()]), import_zod6.z.boolean()))
+  ).or(import_zod6.z.string()).or(import_zod6.z.instanceof(RegExp)).or(import_zod6.z.function(import_zod6.z.tuple([import_zod6.z.string(), import_zod6.z.any()]), import_zod6.z.boolean())).optional(),
+  modulesSort: import_zod6.z.string().optional(),
+  chunkModulesSort: import_zod6.z.string().optional(),
+  nestedModulesSort: import_zod6.z.string().optional(),
+  chunksSort: import_zod6.z.string().optional(),
+  assetsSort: import_zod6.z.string().optional(),
+  performance: import_zod6.z.boolean().optional(),
+  env: import_zod6.z.boolean().optional(),
+  chunkGroupAuxiliary: import_zod6.z.boolean().optional(),
+  chunkGroupChildren: import_zod6.z.boolean().optional(),
+  chunkGroupMaxAssets: import_zod6.z.number().optional(),
+  dependentModules: import_zod6.z.boolean().optional(),
+  chunkOrigins: import_zod6.z.boolean().optional(),
+  runtime: import_zod6.z.boolean().optional(),
+  depth: import_zod6.z.boolean().optional(),
+  reasonsSpace: import_zod6.z.number().optional(),
+  groupReasonsByOrigin: import_zod6.z.boolean().optional(),
+  errorDetails: import_zod6.z.boolean().optional(),
+  errorStack: import_zod6.z.boolean().optional(),
+  moduleTrace: import_zod6.z.boolean().optional(),
+  cachedModules: import_zod6.z.boolean().optional(),
+  cachedAssets: import_zod6.z.boolean().optional(),
+  cached: import_zod6.z.boolean().optional(),
+  errorsSpace: import_zod6.z.number().optional(),
+  warningsSpace: import_zod6.z.number().optional()
 });
-var statsValue = import_zod5.z.boolean().or(statsPresets).or(statsOptions);
-var plugin = import_zod5.z.union([
-  import_zod5.z.custom(),
+var statsValue = import_zod6.z.boolean().or(statsPresets).or(statsOptions);
+var plugin = import_zod6.z.union([
+  import_zod6.z.custom(),
   falsy
 ]);
 var plugins = plugin.array();
-var optimizationRuntimeChunk = import_zod5.z.enum(["single", "multiple"]).or(import_zod5.z.boolean()).or(
-  import_zod5.z.strictObject({
-    name: import_zod5.z.string().or(
-      import_zod5.z.function().args(import_zod5.z.strictObject({ name: import_zod5.z.string() })).returns(import_zod5.z.string())
+var optimizationRuntimeChunk = import_zod6.z.enum(["single", "multiple"]).or(import_zod6.z.boolean()).or(
+  import_zod6.z.strictObject({
+    name: import_zod6.z.string().or(
+      import_zod6.z.function().args(import_zod6.z.strictObject({ name: import_zod6.z.string() })).returns(import_zod6.z.string())
     ).optional()
   })
 );
-var optimizationSplitChunksNameFunction = import_zod5.z.function().args(import_zod5.z.instanceof(Module), import_zod5.z.array(import_zod5.z.instanceof(Chunk)), import_zod5.z.string()).returns(
-  import_zod5.z.string().optional()
+var optimizationSplitChunksNameFunction = import_zod6.z.function().args(import_zod6.z.instanceof(Module), import_zod6.z.array(import_zod6.z.instanceof(Chunk)), import_zod6.z.string()).returns(
+  import_zod6.z.string().optional()
 );
-var optimizationSplitChunksName = import_zod5.z.string().or(import_zod5.z.literal(false)).or(optimizationSplitChunksNameFunction);
-var optimizationSplitChunksChunks = import_zod5.z.enum(["initial", "async", "all"]).or(import_zod5.z.instanceof(RegExp)).or(
-  import_zod5.z.function().args(import_zod5.z.instanceof(Chunk, { message: "Input not instance of Chunk" })).returns(import_zod5.z.boolean())
+var optimizationSplitChunksName = import_zod6.z.string().or(import_zod6.z.literal(false)).or(optimizationSplitChunksNameFunction);
+var optimizationSplitChunksChunks = import_zod6.z.enum(["initial", "async", "all"]).or(import_zod6.z.instanceof(RegExp)).or(
+  import_zod6.z.function().args(import_zod6.z.instanceof(Chunk, { message: "Input not instance of Chunk" })).returns(import_zod6.z.boolean())
 );
-var optimizationSplitChunksSizes = import_zod5.z.number().or(import_zod5.z.record(import_zod5.z.number()));
-var optimizationSplitChunksDefaultSizeTypes = import_zod5.z.array(import_zod5.z.string());
+var optimizationSplitChunksSizes = import_zod6.z.number().or(import_zod6.z.record(import_zod6.z.number()));
+var optimizationSplitChunksDefaultSizeTypes = import_zod6.z.array(import_zod6.z.string());
 var sharedOptimizationSplitChunksCacheGroup = {
   chunks: optimizationSplitChunksChunks.optional(),
   defaultSizeTypes: optimizationSplitChunksDefaultSizeTypes.optional(),
-  minChunks: import_zod5.z.number().min(1).optional(),
-  usedExports: import_zod5.z.boolean().optional(),
+  minChunks: import_zod6.z.number().min(1).optional(),
+  usedExports: import_zod6.z.boolean().optional(),
   name: optimizationSplitChunksName.optional(),
+  filename: filename.optional(),
   minSize: optimizationSplitChunksSizes.optional(),
   maxSize: optimizationSplitChunksSizes.optional(),
   maxAsyncSize: optimizationSplitChunksSizes.optional(),
   maxInitialSize: optimizationSplitChunksSizes.optional(),
-  maxAsyncRequests: import_zod5.z.number().optional(),
-  maxInitialRequests: import_zod5.z.number().optional(),
-  automaticNameDelimiter: import_zod5.z.string().optional()
-};
-var optimizationSplitChunksCacheGroup = import_zod5.z.strictObject({
-  test: import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).or(
-    import_zod5.z.function().args(
-      import_zod5.z.instanceof(Module)
-      /** FIXME: lack of CacheGroupContext */
-    )
+  maxAsyncRequests: import_zod6.z.number().optional(),
+  maxInitialRequests: import_zod6.z.number().optional(),
+  automaticNameDelimiter: import_zod6.z.string().optional()
+};
+var optimizationSplitChunksCacheGroup = import_zod6.z.strictObject({
+  test: import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).or(
+    import_zod6.z.function().args(
+      import_zod6.z.instanceof(Module),
+      import_zod6.z.object({
+        moduleGraph: import_zod6.z.instanceof(ModuleGraph),
+        chunkGraph: import_zod6.z.instanceof(ChunkGraph)
+      })
+    ).returns(import_zod6.z.boolean())
   ).optional(),
-  priority: import_zod5.z.number().optional(),
-  enforce: import_zod5.z.boolean().optional(),
-  filename: filename.optional(),
-  reuseExistingChunk: import_zod5.z.boolean().optional(),
-  type: import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).optional(),
-  idHint: import_zod5.z.string().optional(),
-  layer: import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).or(import_zod5.z.function(import_zod5.z.tuple([import_zod5.z.string().optional()]), import_zod5.z.boolean())).optional(),
+  priority: import_zod6.z.number().optional(),
+  enforce: import_zod6.z.boolean().optional(),
+  reuseExistingChunk: import_zod6.z.boolean().optional(),
+  type: import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).optional(),
+  idHint: import_zod6.z.string().optional(),
+  layer: import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).or(import_zod6.z.function(import_zod6.z.tuple([import_zod6.z.string().optional()]), import_zod6.z.boolean())).optional(),
   ...sharedOptimizationSplitChunksCacheGroup
 });
-var optimizationSplitChunksOptions = import_zod5.z.strictObject({
-  cacheGroups: import_zod5.z.record(import_zod5.z.literal(false).or(optimizationSplitChunksCacheGroup)).optional(),
-  fallbackCacheGroup: import_zod5.z.strictObject({
+var optimizationSplitChunksOptions = import_zod6.z.strictObject({
+  cacheGroups: import_zod6.z.record(import_zod6.z.literal(false).or(optimizationSplitChunksCacheGroup)).optional(),
+  fallbackCacheGroup: import_zod6.z.strictObject({
     chunks: optimizationSplitChunksChunks.optional(),
-    minSize: import_zod5.z.number().optional(),
-    maxSize: import_zod5.z.number().optional(),
-    maxAsyncSize: import_zod5.z.number().optional(),
-    maxInitialSize: import_zod5.z.number().optional(),
-    automaticNameDelimiter: import_zod5.z.string().optional()
+    minSize: import_zod6.z.number().optional(),
+    maxSize: import_zod6.z.number().optional(),
+    maxAsyncSize: import_zod6.z.number().optional(),
+    maxInitialSize: import_zod6.z.number().optional(),
+    automaticNameDelimiter: import_zod6.z.string().optional()
   }).optional(),
-  hidePathInfo: import_zod5.z.boolean().optional(),
+  hidePathInfo: import_zod6.z.boolean().optional(),
   ...sharedOptimizationSplitChunksCacheGroup
 });
-var optimization = import_zod5.z.strictObject({
-  moduleIds: import_zod5.z.enum(["named", "natural", "deterministic"]).optional(),
-  chunkIds: import_zod5.z.enum(["natural", "named", "deterministic", "size", "total-size"]).optional(),
-  minimize: import_zod5.z.boolean().optional(),
-  minimizer: import_zod5.z.literal("...").or(plugin).array().optional(),
-  mergeDuplicateChunks: import_zod5.z.boolean().optional(),
-  splitChunks: import_zod5.z.literal(false).or(optimizationSplitChunksOptions).optional(),
+var optimization = import_zod6.z.strictObject({
+  moduleIds: import_zod6.z.enum(["named", "natural", "deterministic"]).optional(),
+  chunkIds: import_zod6.z.enum(["natural", "named", "deterministic", "size", "total-size"]).optional(),
+  minimize: import_zod6.z.boolean().optional(),
+  minimizer: import_zod6.z.literal("...").or(plugin).array().optional(),
+  mergeDuplicateChunks: import_zod6.z.boolean().optional(),
+  splitChunks: import_zod6.z.literal(false).or(optimizationSplitChunksOptions).optional(),
   runtimeChunk: optimizationRuntimeChunk.optional(),
-  removeAvailableModules: import_zod5.z.boolean().optional(),
-  removeEmptyChunks: import_zod5.z.boolean().optional(),
-  realContentHash: import_zod5.z.boolean().optional(),
-  sideEffects: import_zod5.z.enum(["flag"]).or(import_zod5.z.boolean()).optional(),
-  providedExports: import_zod5.z.boolean().optional(),
-  concatenateModules: import_zod5.z.boolean().optional(),
-  innerGraph: import_zod5.z.boolean().optional(),
-  usedExports: import_zod5.z.enum(["global"]).or(import_zod5.z.boolean()).optional(),
-  mangleExports: import_zod5.z.enum(["size", "deterministic"]).or(import_zod5.z.boolean()).optional(),
-  nodeEnv: import_zod5.z.union([import_zod5.z.string(), import_zod5.z.literal(false)]).optional(),
-  emitOnErrors: import_zod5.z.boolean().optional(),
-  avoidEntryIife: import_zod5.z.boolean().optional()
+  removeAvailableModules: import_zod6.z.boolean().optional(),
+  removeEmptyChunks: import_zod6.z.boolean().optional(),
+  realContentHash: import_zod6.z.boolean().optional(),
+  sideEffects: import_zod6.z.enum(["flag"]).or(import_zod6.z.boolean()).optional(),
+  providedExports: import_zod6.z.boolean().optional(),
+  concatenateModules: import_zod6.z.boolean().optional(),
+  innerGraph: import_zod6.z.boolean().optional(),
+  usedExports: import_zod6.z.enum(["global"]).or(import_zod6.z.boolean()).optional(),
+  mangleExports: import_zod6.z.enum(["size", "deterministic"]).or(import_zod6.z.boolean()).optional(),
+  nodeEnv: import_zod6.z.union([import_zod6.z.string(), import_zod6.z.literal(false)]).optional(),
+  emitOnErrors: import_zod6.z.boolean().optional(),
+  avoidEntryIife: import_zod6.z.boolean().optional()
 });
-var rspackFutureOptions = import_zod5.z.strictObject({
-  bundlerInfo: import_zod5.z.strictObject({
-    version: import_zod5.z.string().optional(),
-    bundler: import_zod5.z.string().optional(),
-    force: import_zod5.z.boolean().or(import_zod5.z.array(import_zod5.z.enum(["version", "uniqueId"]))).optional()
+var rspackFutureOptions = import_zod6.z.strictObject({
+  bundlerInfo: import_zod6.z.strictObject({
+    version: import_zod6.z.string().optional(),
+    bundler: import_zod6.z.string().optional(),
+    force: import_zod6.z.boolean().or(import_zod6.z.array(import_zod6.z.enum(["version", "uniqueId"]))).optional()
   }).optional()
 });
-var listenOptions = import_zod5.z.object({
-  port: import_zod5.z.number().optional(),
-  host: import_zod5.z.string().optional(),
-  backlog: import_zod5.z.number().optional(),
-  path: import_zod5.z.string().optional(),
-  exclusive: import_zod5.z.boolean().optional(),
-  readableAll: import_zod5.z.boolean().optional(),
-  writableAll: import_zod5.z.boolean().optional(),
-  ipv6Only: import_zod5.z.boolean().optional()
+var listenOptions = import_zod6.z.object({
+  port: import_zod6.z.number().optional(),
+  host: import_zod6.z.string().optional(),
+  backlog: import_zod6.z.number().optional(),
+  path: import_zod6.z.string().optional(),
+  exclusive: import_zod6.z.boolean().optional(),
+  readableAll: import_zod6.z.boolean().optional(),
+  writableAll: import_zod6.z.boolean().optional(),
+  ipv6Only: import_zod6.z.boolean().optional()
 });
-var experimentCacheOptions = import_zod5.z.object({
-  type: import_zod5.z.enum(["memory"])
+var experimentCacheOptions = import_zod6.z.object({
+  type: import_zod6.z.enum(["memory"])
 }).or(
-  import_zod5.z.object({
-    type: import_zod5.z.enum(["persistent"]),
-    buildDependencies: import_zod5.z.string().array().optional(),
-    version: import_zod5.z.string().optional(),
-    snapshot: import_zod5.z.object({
-      immutablePaths: import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).array().optional(),
-      unmanagedPaths: import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).array().optional(),
-      managedPaths: import_zod5.z.string().or(import_zod5.z.instanceof(RegExp)).array().optional()
+  import_zod6.z.object({
+    type: import_zod6.z.enum(["persistent"]),
+    buildDependencies: import_zod6.z.string().array().optional(),
+    version: import_zod6.z.string().optional(),
+    snapshot: import_zod6.z.object({
+      immutablePaths: import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).array().optional(),
+      unmanagedPaths: import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).array().optional(),
+      managedPaths: import_zod6.z.string().or(import_zod6.z.instanceof(RegExp)).array().optional()
     }).optional(),
-    storage: import_zod5.z.object({
-      type: import_zod5.z.enum(["filesystem"]),
-      directory: import_zod5.z.string().optional()
+    storage: import_zod6.z.object({
+      type: import_zod6.z.enum(["filesystem"]),
+      directory: import_zod6.z.string().optional()
     }).optional()
   })
 );
-var lazyCompilationOptions = import_zod5.z.object({
-  backend: import_zod5.z.object({
-    client: import_zod5.z.string().optional(),
-    listen: import_zod5.z.number().or(listenOptions).or(import_zod5.z.function().args(import_zod5.z.any()).returns(import_zod5.z.void())).optional(),
-    protocol: import_zod5.z.enum(["http", "https"]).optional(),
-    server: import_zod5.z.record(import_zod5.z.any()).or(import_zod5.z.function().returns(import_zod5.z.any())).optional()
+var lazyCompilationOptions = import_zod6.z.object({
+  backend: import_zod6.z.object({
+    client: import_zod6.z.string().optional(),
+    listen: import_zod6.z.number().or(listenOptions).or(import_zod6.z.function().args(import_zod6.z.any()).returns(import_zod6.z.void())).optional(),
+    protocol: import_zod6.z.enum(["http", "https"]).optional(),
+    server: import_zod6.z.record(import_zod6.z.any()).or(import_zod6.z.function().returns(import_zod6.z.any())).optional()
   }).optional(),
-  imports: import_zod5.z.boolean().optional(),
-  entries: import_zod5.z.boolean().optional(),
-  test: import_zod5.z.instanceof(RegExp).or(import_zod5.z.function().args(import_zod5.z.custom()).returns(import_zod5.z.boolean())).optional()
+  imports: import_zod6.z.boolean().optional(),
+  entries: import_zod6.z.boolean().optional(),
+  test: import_zod6.z.instanceof(RegExp).or(import_zod6.z.function().args(import_zod6.z.custom()).returns(import_zod6.z.boolean())).optional()
 });
-var incremental = import_zod5.z.strictObject({
-  make: import_zod5.z.boolean().optional(),
-  inferAsyncModules: import_zod5.z.boolean().optional(),
-  providedExports: import_zod5.z.boolean().optional(),
-  dependenciesDiagnostics: import_zod5.z.boolean().optional(),
-  sideEffects: import_zod5.z.boolean().optional(),
-  buildChunkGraph: import_zod5.z.boolean().optional(),
-  moduleIds: import_zod5.z.boolean().optional(),
-  chunkIds: import_zod5.z.boolean().optional(),
-  modulesHashes: import_zod5.z.boolean().optional(),
-  modulesCodegen: import_zod5.z.boolean().optional(),
-  modulesRuntimeRequirements: import_zod5.z.boolean().optional(),
-  chunksRuntimeRequirements: import_zod5.z.boolean().optional(),
-  chunksHashes: import_zod5.z.boolean().optional(),
-  chunksRender: import_zod5.z.boolean().optional(),
-  emitAssets: import_zod5.z.boolean().optional()
+var incremental = import_zod6.z.strictObject({
+  make: import_zod6.z.boolean().optional(),
+  inferAsyncModules: import_zod6.z.boolean().optional(),
+  providedExports: import_zod6.z.boolean().optional(),
+  dependenciesDiagnostics: import_zod6.z.boolean().optional(),
+  sideEffects: import_zod6.z.boolean().optional(),
+  buildChunkGraph: import_zod6.z.boolean().optional(),
+  moduleIds: import_zod6.z.boolean().optional(),
+  chunkIds: import_zod6.z.boolean().optional(),
+  modulesHashes: import_zod6.z.boolean().optional(),
+  modulesCodegen: import_zod6.z.boolean().optional(),
+  modulesRuntimeRequirements: import_zod6.z.boolean().optional(),
+  chunksRuntimeRequirements: import_zod6.z.boolean().optional(),
+  chunksHashes: import_zod6.z.boolean().optional(),
+  chunksRender: import_zod6.z.boolean().optional(),
+  emitAssets: import_zod6.z.boolean().optional()
 });
-var experiments = import_zod5.z.strictObject({
-  cache: import_zod5.z.boolean().optional().or(experimentCacheOptions),
-  lazyCompilation: import_zod5.z.boolean().optional().or(lazyCompilationOptions),
-  asyncWebAssembly: import_zod5.z.boolean().optional(),
-  outputModule: import_zod5.z.boolean().optional(),
-  topLevelAwait: import_zod5.z.boolean().optional(),
-  css: import_zod5.z.boolean().optional(),
-  layers: import_zod5.z.boolean().optional(),
-  incremental: import_zod5.z.boolean().or(incremental).optional(),
-  parallelCodeSplitting: import_zod5.z.boolean().optional(),
-  futureDefaults: import_zod5.z.boolean().optional(),
+var experiments = import_zod6.z.strictObject({
+  cache: import_zod6.z.boolean().optional().or(experimentCacheOptions),
+  lazyCompilation: import_zod6.z.boolean().optional().or(lazyCompilationOptions),
+  asyncWebAssembly: import_zod6.z.boolean().optional(),
+  outputModule: import_zod6.z.boolean().optional(),
+  topLevelAwait: import_zod6.z.boolean().optional(),
+  css: import_zod6.z.boolean().optional(),
+  layers: import_zod6.z.boolean().optional(),
+  incremental: import_zod6.z.boolean().or(incremental).optional(),
+  parallelCodeSplitting: import_zod6.z.boolean().optional(),
+  futureDefaults: import_zod6.z.boolean().optional(),
   rspackFuture: rspackFutureOptions.optional()
 });
-var watch = import_zod5.z.boolean();
-var watchOptions = import_zod5.z.strictObject({
-  aggregateTimeout: import_zod5.z.number().optional(),
-  followSymlinks: import_zod5.z.boolean().optional(),
-  ignored: import_zod5.z.string().array().or(import_zod5.z.instanceof(RegExp)).or(import_zod5.z.string()).optional(),
-  poll: import_zod5.z.number().or(import_zod5.z.boolean()).optional(),
-  stdin: import_zod5.z.boolean().optional()
+var watch = import_zod6.z.boolean();
+var watchOptions = import_zod6.z.strictObject({
+  aggregateTimeout: import_zod6.z.number().optional(),
+  followSymlinks: import_zod6.z.boolean().optional(),
+  ignored: import_zod6.z.string().array().or(import_zod6.z.instanceof(RegExp)).or(import_zod6.z.string()).optional(),
+  poll: import_zod6.z.number().or(import_zod6.z.boolean()).optional(),
+  stdin: import_zod6.z.boolean().optional()
 });
-var devServer = import_zod5.z.custom();
-var ignoreWarnings = import_zod5.z.instanceof(RegExp).or(
-  import_zod5.z.function().args(import_zod5.z.instanceof(Error), import_zod5.z.custom()).returns(import_zod5.z.boolean())
+var devServer = import_zod6.z.custom();
+var ignoreWarnings = import_zod6.z.instanceof(RegExp).or(
+  import_zod6.z.function().args(import_zod6.z.instanceof(Error), import_zod6.z.custom()).returns(import_zod6.z.boolean())
 ).array();
-var profile = import_zod5.z.boolean();
-var amd = import_zod5.z.literal(false).or(import_zod5.z.record(import_zod5.z.any()));
-var bail = import_zod5.z.boolean();
-var performance = import_zod5.z.strictObject({
-  assetFilter: import_zod5.z.function().args(import_zod5.z.string()).returns(import_zod5.z.boolean()).optional(),
-  hints: import_zod5.z.enum(["error", "warning"]).or(import_zod5.z.literal(false)).optional(),
-  maxAssetSize: import_zod5.z.number().optional(),
-  maxEntrypointSize: import_zod5.z.number().optional()
-}).or(import_zod5.z.literal(false));
-var rspackOptions = import_zod5.z.strictObject({
+var profile = import_zod6.z.boolean();
+var amd = import_zod6.z.literal(false).or(import_zod6.z.record(import_zod6.z.any()));
+var bail = import_zod6.z.boolean();
+var performance = import_zod6.z.strictObject({
+  assetFilter: import_zod6.z.function().args(import_zod6.z.string()).returns(import_zod6.z.boolean()).optional(),
+  hints: import_zod6.z.enum(["error", "warning"]).or(import_zod6.z.literal(false)).optional(),
+  maxAssetSize: import_zod6.z.number().optional(),
+  maxEntrypointSize: import_zod6.z.number().optional()
+}).or(import_zod6.z.literal(false));
+var rspackOptions = import_zod6.z.strictObject({
   name: name.optional(),
   dependencies: dependencies.optional(),
   entry: entry.optional(),
@@ -13324,8 +13615,8 @@ var Watching = class {
 };
 
 // src/util/bindingVersionCheck.ts
-var import_node_fs3 = require("fs");
-var import_node_path11 = __toESM(require("path"));
+var import_node_fs4 = require("fs");
+var import_node_path12 = __toESM(require("path"));
 var NodePlatformArchToAbi = {
   android: {
     arm64: "",
@@ -13359,7 +13650,7 @@ function isMusl() {
   if (!process.report || typeof process.report.getReport !== "function") {
     try {
       const lddPath = require("child_process").execSync("which ldd").toString().trim();
-      return (0, import_node_fs3.readFileSync)(lddPath, "utf8").includes("musl");
+      return (0, import_node_fs4.readFileSync)(lddPath, "utf8").includes("musl");
     } catch (e) {
       return true;
     }
@@ -13397,10 +13688,10 @@ var checkVersion = () => {
   }
   let ADDON_VERSION;
   try {
-    const BINDING_PKG_DIR = import_node_path11.default.dirname(
+    const BINDING_PKG_DIR = import_node_path12.default.dirname(
       require.resolve("@rspack/binding/package.json")
     );
-    const isLocal = (0, import_node_fs3.readdirSync)(BINDING_PKG_DIR).some(
+    const isLocal = (0, import_node_fs4.readdirSync)(BINDING_PKG_DIR).some(
       (item) => item === `rspack.${platformArchAbi}.node`
     );
     if (isLocal) {
@@ -15078,7 +15369,7 @@ var Compiler = class _Compiler {
     );
     const instanceBinding = require("@rspack/binding");
     this.#registers = this.#createHooksRegisters();
-    this.#instance = new instanceBinding.Rspack(
+    this.#instance = new instanceBinding.JsCompiler(
       this.compilerPath,
       rawOptions,
       this.#builtinPlugins,
@@ -18996,7 +19287,7 @@ var RspackOptionsApply = class {
         lazyOptions.imports ?? true,
         typeof lazyOptions.test === "function" ? (jsModule) => lazyOptions.test.call(
           lazyOptions,
-          new Module(jsModule)
+          Module.__from_binding(jsModule)
         ) : lazyOptions.test,
         lazyOptions.backend
       ).apply(compiler);
@@ -19146,12 +19437,12 @@ var matchObject = (obj, str) => {
 };
 
 // src/lib/DllPlugin.ts
-var import_zod6 = __toESM(require("../compiled/zod/index.js"));
+var import_zod7 = __toESM(require("../compiled/zod/index.js"));
 
 // src/builtin-plugin/FlagAllModulesAsUsedPlugin.ts
-var import_binding74 = require("@rspack/binding");
+var import_binding75 = require("@rspack/binding");
 var FlagAllModulesAsUsedPlugin = create2(
-  import_binding74.BuiltinPluginName.FlagAllModulesAsUsedPlugin,
+  import_binding75.BuiltinPluginName.FlagAllModulesAsUsedPlugin,
   (explanation) => {
     return {
       explanation
@@ -19160,13 +19451,13 @@ var FlagAllModulesAsUsedPlugin = create2(
 );
 
 // src/lib/DllPlugin.ts
-var dllPluginOptions = import_zod6.default.object({
-  context: import_zod6.default.string().optional(),
-  entryOnly: import_zod6.default.boolean().optional(),
-  format: import_zod6.default.boolean().optional(),
-  name: import_zod6.default.string().optional(),
-  path: import_zod6.default.string(),
-  type: import_zod6.default.string().optional()
+var dllPluginOptions = import_zod7.default.object({
+  context: import_zod7.default.string().optional(),
+  entryOnly: import_zod7.default.boolean().optional(),
+  format: import_zod7.default.boolean().optional(),
+  name: import_zod7.default.string().optional(),
+  path: import_zod7.default.string(),
+  type: import_zod7.default.string().optional()
 });
 var DllPlugin = class _DllPlugin {
   constructor(options) {
@@ -19200,16 +19491,16 @@ var DllPlugin = class _DllPlugin {
 };
 
 // src/lib/DllReferencePlugin.ts
-var import_zod7 = __toESM(require("../compiled/zod/index.js"));
-var dllReferencePluginOptionsContentItem = import_zod7.default.object({
-  buildMeta: import_zod7.default.custom().optional(),
-  exports: import_zod7.default.array(import_zod7.default.string()).or(import_zod7.default.literal(true)).optional(),
-  id: import_zod7.default.string().or(import_zod7.default.number()).optional()
+var import_zod8 = __toESM(require("../compiled/zod/index.js"));
+var dllReferencePluginOptionsContentItem = import_zod8.default.object({
+  buildMeta: import_zod8.default.custom().optional(),
+  exports: import_zod8.default.array(import_zod8.default.string()).or(import_zod8.default.literal(true)).optional(),
+  id: import_zod8.default.string().or(import_zod8.default.number()).optional()
 });
-var dllReferencePluginOptionsContent = import_zod7.default.record(
+var dllReferencePluginOptionsContent = import_zod8.default.record(
   dllReferencePluginOptionsContentItem
 );
-var dllReferencePluginOptionsSourceType = import_zod7.default.enum([
+var dllReferencePluginOptionsSourceType = import_zod8.default.enum([
   "var",
   "assign",
   "this",
@@ -19225,29 +19516,29 @@ var dllReferencePluginOptionsSourceType = import_zod7.default.enum([
   "jsonp",
   "system"
 ]);
-var dllReferencePluginOptionsManifest = import_zod7.default.object({
+var dllReferencePluginOptionsManifest = import_zod8.default.object({
   content: dllReferencePluginOptionsContent,
-  name: import_zod7.default.string().optional(),
+  name: import_zod8.default.string().optional(),
   type: dllReferencePluginOptionsSourceType.optional()
 });
-var dllReferencePluginOptions = import_zod7.default.union([
-  import_zod7.default.object({
-    context: import_zod7.default.string().optional(),
-    extensions: import_zod7.default.array(import_zod7.default.string()).optional(),
-    manifest: import_zod7.default.string().or(dllReferencePluginOptionsManifest),
-    name: import_zod7.default.string().optional(),
-    scope: import_zod7.default.string().optional(),
+var dllReferencePluginOptions = import_zod8.default.union([
+  import_zod8.default.object({
+    context: import_zod8.default.string().optional(),
+    extensions: import_zod8.default.array(import_zod8.default.string()).optional(),
+    manifest: import_zod8.default.string().or(dllReferencePluginOptionsManifest),
+    name: import_zod8.default.string().optional(),
+    scope: import_zod8.default.string().optional(),
     sourceType: dllReferencePluginOptionsSourceType.optional(),
-    type: import_zod7.default.enum(["require", "object"]).optional()
+    type: import_zod8.default.enum(["require", "object"]).optional()
   }),
-  import_zod7.default.object({
+  import_zod8.default.object({
     content: dllReferencePluginOptionsContent,
-    context: import_zod7.default.string().optional(),
-    extensions: import_zod7.default.array(import_zod7.default.string()).optional(),
-    name: import_zod7.default.string(),
-    scope: import_zod7.default.string().optional(),
+    context: import_zod8.default.string().optional(),
+    extensions: import_zod8.default.array(import_zod8.default.string()).optional(),
+    name: import_zod8.default.string(),
+    scope: import_zod8.default.string().optional(),
     sourceType: dllReferencePluginOptionsSourceType.optional(),
-    type: import_zod7.default.enum(["require", "object"]).optional()
+    type: import_zod8.default.enum(["require", "object"]).optional()
   })
 ]);
 var DllReferencePlugin = class _DllReferencePlugin {
@@ -20040,9 +20331,9 @@ var NodeTemplatePlugin = class {
 };
 
 // src/container/ModuleFederationRuntimePlugin.ts
-var import_binding75 = require("@rspack/binding");
+var import_binding76 = require("@rspack/binding");
 var ModuleFederationRuntimePlugin = create2(
-  import_binding75.BuiltinPluginName.ModuleFederationRuntimePlugin,
+  import_binding76.BuiltinPluginName.ModuleFederationRuntimePlugin,
   () => {
   }
 );
@@ -20238,10 +20529,10 @@ function getDefaultEntryRuntime(paths, options, compiler) {
 }
 
 // src/sharing/ConsumeSharedPlugin.ts
-var import_binding77 = require("@rspack/binding");
+var import_binding78 = require("@rspack/binding");
 
 // src/sharing/ShareRuntimePlugin.ts
-var import_binding76 = require("@rspack/binding");
+var import_binding77 = require("@rspack/binding");
 var compilerSet = /* @__PURE__ */ new WeakSet();
 function isSingleton(compiler) {
   return compilerSet.has(compiler);
@@ -20253,7 +20544,7 @@ var ShareRuntimePlugin = class extends RspackBuiltinPlugin {
   constructor(enhanced = false) {
     super();
     this.enhanced = enhanced;
-    this.name = import_binding76.BuiltinPluginName.ShareRuntimePlugin;
+    this.name = import_binding77.BuiltinPluginName.ShareRuntimePlugin;
   }
   raw(compiler) {
     if (isSingleton(compiler)) return;
@@ -20272,7 +20563,7 @@ function isRequiredVersion(str) {
 var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding77.BuiltinPluginName.ConsumeSharedPlugin;
+    this.name = import_binding78.BuiltinPluginName.ConsumeSharedPlugin;
     this._options = {
       consumes: parseOptions(
         options.consumes,
@@ -20335,11 +20626,11 @@ var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/sharing/ProvideSharedPlugin.ts
-var import_binding78 = require("@rspack/binding");
+var import_binding79 = require("@rspack/binding");
 var ProvideSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding78.BuiltinPluginName.ProvideSharedPlugin;
+    this.name = import_binding79.BuiltinPluginName.ProvideSharedPlugin;
     this._provides = parseOptions(
       options.provides,
       (item) => {
@@ -20444,11 +20735,11 @@ var SharePlugin = class {
 };
 
 // src/container/ContainerPlugin.ts
-var import_binding79 = require("@rspack/binding");
+var import_binding80 = require("@rspack/binding");
 var ContainerPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding79.BuiltinPluginName.ContainerPlugin;
+    this.name = import_binding80.BuiltinPluginName.ContainerPlugin;
     this._options = {
       name: options.name,
       shareScope: options.shareScope || "default",
@@ -20492,11 +20783,11 @@ var ContainerPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/container/ContainerReferencePlugin.ts
-var import_binding80 = require("@rspack/binding");
+var import_binding81 = require("@rspack/binding");
 var ContainerReferencePlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding80.BuiltinPluginName.ContainerReferencePlugin;
+    this.name = import_binding81.BuiltinPluginName.ContainerReferencePlugin;
     this._options = {
       remoteType: options.remoteType,
       remotes: parseOptions(
@@ -20581,7 +20872,7 @@ var ModuleFederationPluginV1 = class {
 };
 
 // src/exports.ts
-var import_binding81 = require("@rspack/binding");
+var import_binding82 = require("@rspack/binding");
 var rspackVersion = import_package.version;
 var version = import_package.webpackVersion;
 var WebpackError2 = Error;
@@ -20628,7 +20919,7 @@ var sharing = {
 var experiments2 = {
   globalTrace: {
     async register(filter, layer2, output2) {
-      (0, import_binding81.registerGlobalTrace)(filter, layer2, output2);
+      (0, import_binding82.registerGlobalTrace)(filter, layer2, output2);
       if (layer2 === "otel") {
         try {
           const { initOpenTelemetry } = await import("@rspack/tracing");
@@ -20642,7 +20933,7 @@ var experiments2 = {
       }
     },
     async cleanup() {
-      (0, import_binding81.cleanupGlobalTrace)();
+      (0, import_binding82.cleanupGlobalTrace)();
       try {
         const { shutdownOpenTelemetry } = await import("@rspack/tracing");
         await shutdownOpenTelemetry();
@@ -20656,7 +20947,8 @@ var experiments2 = {
    *
    * @internal
    */
-  RsdoctorPlugin
+  RsdoctorPlugin,
+  SubresourceIntegrityPlugin
 };
 
 // src/rspack.ts