@rspack/core 1.3.0-beta.1 → 1.3.1

package/dist/index.js

@@ -148,15 +148,15 @@ var require_CachedInputFileSystem = __commonJS({
   "../../node_modules/.pnpm/enhanced-resolve@5.18.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js"(exports2, module2) {
     "use strict";
     var nextTick = require("process").nextTick;
-    var dirname4 = (path11) => {
-      let idx = path11.length - 1;
+    var dirname4 = (path13) => {
+      let idx = path13.length - 1;
       while (idx >= 0) {
-        const c = path11.charCodeAt(idx);
+        const c = path13.charCodeAt(idx);
         if (c === 47 || c === 92) break;
         idx--;
       }
       if (idx < 0) return "";
-      return path11.slice(0, idx);
+      return path13.slice(0, idx);
     };
     var runCallbacks = (callbacks, err, result2) => {
       if (callbacks.length === 1) {
@@ -193,13 +193,13 @@ var require_CachedInputFileSystem = __commonJS({
            * @param {FileSystemCallback<any>=} callback callback
            * @returns {any} result
            */
-          (path11, options, callback) => {
+          (path13, options, callback) => {
             if (typeof options === "function") {
               callback = /** @type {FileSystemCallback<any>} */
               options;
               options = void 0;
             }
-            if (typeof path11 !== "string" && !Buffer.isBuffer(path11) && !(path11 instanceof URL) && typeof path11 !== "number") {
+            if (typeof path13 !== "string" && !Buffer.isBuffer(path13) && !(path13 instanceof URL) && typeof path13 !== "number") {
               callback(
                 new TypeError("path must be a string, Buffer, URL or number")
               );
@@ -210,26 +210,26 @@ var require_CachedInputFileSystem = __commonJS({
                 /** @type {Function} */
                 this._provider.call(
                   this._providerContext,
-                  path11,
+                  path13,
                   options,
                   callback
                 )
               );
             }
-            let callbacks = this._activeAsyncOperations.get(path11);
+            let callbacks = this._activeAsyncOperations.get(path13);
             if (callbacks) {
               callbacks.push(callback);
               return;
             }
-            this._activeAsyncOperations.set(path11, callbacks = [callback]);
+            this._activeAsyncOperations.set(path13, callbacks = [callback]);
             provider(
-              path11,
+              path13,
               /**
                * @param {Error} err error
                * @param {any} result result
                */
               (err, result2) => {
-                this._activeAsyncOperations.delete(path11);
+                this._activeAsyncOperations.delete(path13);
                 runCallbacks(callbacks, err, result2);
               }
             );
@@ -241,12 +241,12 @@ var require_CachedInputFileSystem = __commonJS({
            * @param {object=} options options
            * @returns {any} result
            */
-          (path11, options) => {
+          (path13, options) => {
             return (
               /** @type {Function} */
               this._syncProvider.call(
                 this._providerContext,
-                path11,
+                path13,
                 options
               )
             );
@@ -292,22 +292,22 @@ var require_CachedInputFileSystem = __commonJS({
        * @param {FileSystemCallback<any>} callback callback
        * @returns {void}
        */
-      provide(path11, options, callback) {
+      provide(path13, options, callback) {
         if (typeof options === "function") {
           callback = options;
           options = void 0;
         }
-        if (typeof path11 !== "string" && !Buffer.isBuffer(path11) && !(path11 instanceof URL) && typeof path11 !== "number") {
+        if (typeof path13 !== "string" && !Buffer.isBuffer(path13) && !(path13 instanceof URL) && typeof path13 !== "number") {
           callback(new TypeError("path must be a string, Buffer, URL or number"));
           return;
         }
-        const strPath = typeof path11 !== "string" ? path11.toString() : path11;
+        const strPath = typeof path13 !== "string" ? path13.toString() : path13;
         if (options) {
           return (
             /** @type {Function} */
             this._provider.call(
               this._providerContext,
-              path11,
+              path13,
               options,
               callback
             )
@@ -329,7 +329,7 @@ var require_CachedInputFileSystem = __commonJS({
         this._activeAsyncOperations.set(strPath, callbacks = [callback]);
         this._provider.call(
           this._providerContext,
-          path11,
+          path13,
           /**
            * @param {Error | null} err error
            * @param {any} [result] result
@@ -352,17 +352,17 @@ var require_CachedInputFileSystem = __commonJS({
        * @param {any} options options
        * @returns {any} result
        */
-      provideSync(path11, options) {
-        if (typeof path11 !== "string" && !Buffer.isBuffer(path11) && !(path11 instanceof URL) && typeof path11 !== "number") {
+      provideSync(path13, options) {
+        if (typeof path13 !== "string" && !Buffer.isBuffer(path13) && !(path13 instanceof URL) && typeof path13 !== "number") {
           throw new TypeError("path must be a string");
         }
-        const strPath = typeof path11 !== "string" ? path11.toString() : path11;
+        const strPath = typeof path13 !== "string" ? path13.toString() : path13;
         if (options) {
           return (
             /** @type {Function} */
             this._syncProvider.call(
               this._providerContext,
-              path11,
+              path13,
               options
             )
           );
@@ -382,7 +382,7 @@ var require_CachedInputFileSystem = __commonJS({
           result2 = /** @type {Function} */
           this._syncProvider.call(
             this._providerContext,
-            path11
+            path13
           );
         } catch (err) {
           this._storeResult(
@@ -471,11 +471,11 @@ var require_CachedInputFileSystem = __commonJS({
        * @param {Error | null} err error
        * @param {any} result result
        */
-      _storeResult(path11, err, result2) {
-        if (this._data.has(path11)) return;
+      _storeResult(path13, err, result2) {
+        if (this._data.has(path13)) return;
         const level = this._levels[this._currentLevel];
-        this._data.set(path11, { err, result: result2, level });
-        level.add(path11);
+        this._data.set(path13, { err, result: result2, level });
+        level.add(path13);
       }
       _decayLevel() {
         const nextLevel = (this._currentLevel + 1) % this._levels.length;
@@ -610,8 +610,8 @@ var require_CachedInputFileSystem = __commonJS({
            * @param {string} path path
            * @param {FileSystemCallback<any>} callback
            */
-          ((path11, callback) => {
-            this.readFile(path11, (err, buffer) => {
+          ((path13, callback) => {
+            this.readFile(path13, (err, buffer) => {
               if (err) return callback(err);
               if (!buffer || buffer.length === 0)
                 return callback(new Error("No file content"));
@@ -632,8 +632,8 @@ var require_CachedInputFileSystem = __commonJS({
            * @param {string} path path
            * @returns {any} result
            */
-          ((path11) => {
-            const buffer = this.readFileSync(path11);
+          ((path13) => {
+            const buffer = this.readFileSync(path13);
             const data = JSON.parse(buffer.toString("utf-8"));
             return data;
           }),
@@ -689,28 +689,28 @@ var require_CachedInputFileSystem = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AsyncDependenciesBlock: () => import_binding89.AsyncDependenciesBlock,
+  AsyncDependenciesBlock: () => import_binding90.AsyncDependenciesBlock,
   BannerPlugin: () => BannerPlugin,
   CircularDependencyRspackPlugin: () => CircularDependencyRspackPlugin,
   Compilation: () => Compilation,
   Compiler: () => Compiler,
-  ConcatenatedModule: () => import_binding80.ConcatenatedModule,
-  ContextModule: () => import_binding79.ContextModule,
+  ConcatenatedModule: () => import_binding81.ConcatenatedModule,
+  ContextModule: () => import_binding80.ContextModule,
   ContextReplacementPlugin: () => ContextReplacementPlugin,
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
-  Dependency: () => import_binding89.Dependency,
+  Dependency: () => import_binding90.Dependency,
   DllPlugin: () => DllPlugin,
   DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
-  EntryDependency: () => import_binding89.EntryDependency,
+  EntryDependency: () => import_binding90.EntryDependency,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
   EnvironmentPlugin: () => EnvironmentPlugin,
   EvalDevToolModulePlugin: () => EvalDevToolModulePlugin,
   EvalSourceMapDevToolPlugin: () => EvalSourceMapDevToolPlugin,
-  ExternalModule: () => import_binding81.ExternalModule,
+  ExternalModule: () => import_binding82.ExternalModule,
   ExternalsPlugin: () => ExternalsPlugin,
   HotModuleReplacementPlugin: () => HotModuleReplacementPlugin,
   HtmlRspackPlugin: () => HtmlRspackPlugin,
@@ -762,28 +762,28 @@ module.exports = __toCommonJS(index_exports);
 // src/exports.ts
 var exports_exports = {};
 __export(exports_exports, {
-  AsyncDependenciesBlock: () => import_binding89.AsyncDependenciesBlock,
+  AsyncDependenciesBlock: () => import_binding90.AsyncDependenciesBlock,
   BannerPlugin: () => BannerPlugin,
   CircularDependencyRspackPlugin: () => CircularDependencyRspackPlugin,
   Compilation: () => Compilation,
   Compiler: () => Compiler,
-  ConcatenatedModule: () => import_binding80.ConcatenatedModule,
-  ContextModule: () => import_binding79.ContextModule,
+  ConcatenatedModule: () => import_binding81.ConcatenatedModule,
+  ContextModule: () => import_binding80.ContextModule,
   ContextReplacementPlugin: () => ContextReplacementPlugin,
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
-  Dependency: () => import_binding89.Dependency,
+  Dependency: () => import_binding90.Dependency,
   DllPlugin: () => DllPlugin,
   DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
-  EntryDependency: () => import_binding89.EntryDependency,
+  EntryDependency: () => import_binding90.EntryDependency,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
   EnvironmentPlugin: () => EnvironmentPlugin,
   EvalDevToolModulePlugin: () => EvalDevToolModulePlugin,
   EvalSourceMapDevToolPlugin: () => EvalSourceMapDevToolPlugin,
-  ExternalModule: () => import_binding81.ExternalModule,
+  ExternalModule: () => import_binding82.ExternalModule,
   ExternalsPlugin: () => ExternalsPlugin,
   HotModuleReplacementPlugin: () => HotModuleReplacementPlugin,
   HtmlRspackPlugin: () => HtmlRspackPlugin,
@@ -1288,7 +1288,10 @@ var toBuffer = (bufLike) => {
   if (typeof bufLike === "string") {
     return Buffer.from(bufLike);
   }
-  throw new Error("Buffer or string expected");
+  if (bufLike instanceof Uint8Array) {
+    return Buffer.from(bufLike.buffer);
+  }
+  throw new Error("Buffer, Uint8Array or string expected");
 };
 var toObject = (input) => {
   let s;
@@ -2550,6 +2553,13 @@ var JsSource = class extends import_webpack_sources.Source {
 };
 
 // src/Compilation.ts
+var checkCompilation = (compilation) => {
+  if (!(compilation instanceof Compilation)) {
+    throw new TypeError(
+      `The 'compilation' argument must be an instance of Compilation. This usually occurs when multiple versions of "@rspack/core" are used, or when the code in "@rspack/core" is executed multiple times.`
+    );
+  }
+};
 var _inner, _shutdown, _addIncludeDispatcher, _Compilation_instances, createCachedAssets_fn, _rebuildModuleTask;
 var _Compilation = class _Compilation {
   constructor(compiler, inner) {
@@ -5138,7 +5148,6 @@ function toFeatures(featureOptions) {
 // src/loader-runner/index.ts
 var import_node_querystring = __toESM(require("querystring"));
 var import_node_assert2 = __toESM(require("assert"));
-var import_node_util4 = require("util");
 var import_binding3 = require("@rspack/binding");
 var import_webpack_sources2 = require("../compiled/webpack-sources/index.js");
 
@@ -5206,11 +5215,7 @@ Object.defineProperty(binding.NormalModule, "getCompilationHooks", {
   enumerable: true,
   configurable: true,
   value(compilation) {
-    if (!(compilation instanceof Compilation)) {
-      throw new TypeError(
-        "The 'compilation' argument must be an instance of Compilation"
-      );
-    }
+    checkCompilation(compilation);
     let hooks = compilationHooksMap.get(compilation);
     if (hooks === void 0) {
       hooks = {
@@ -5243,6 +5248,162 @@ Object.defineProperty(binding.NormalModule, "getCompilationHooks", {
   }
 });
 
+// src/loader-runner/service.ts
+var import_node_path3 = __toESM(require("path"));
+var import_node_worker_threads = require("worker_threads");
+var pool;
+var ensureLoaderWorkerPool = async () => {
+  if (pool) {
+    return pool;
+  }
+  return pool = import("tinypool").then(({ Tinypool }) => {
+    const cpus = require("os").cpus().length;
+    const availableThreads = Math.max(cpus - 1, 1);
+    const pool2 = new Tinypool({
+      filename: import_node_path3.default.resolve(__dirname, "worker.js"),
+      useAtomics: false,
+      maxThreads: availableThreads,
+      minThreads: availableThreads,
+      concurrentTasksPerWorker: 1
+    });
+    return pool2;
+  });
+};
+function isWorkerDoneMessage(message) {
+  return message.type === "done";
+}
+function isWorkerDoneErrorMessage(message) {
+  return message.type === "done-error";
+}
+function isWorkerRequestMessage(message) {
+  return message.type === "request";
+}
+function serializeError(error) {
+  if (error instanceof Error || error && typeof error === "object" && "message" in error) {
+    return {
+      ...error,
+      name: error.name,
+      stack: error.stack,
+      message: error.message
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      name: "Error",
+      message: error
+    };
+  }
+  throw new Error(
+    "Failed to serialize error, only string, Error instances and objects with a message property are supported"
+  );
+}
+var run = async (task, options) => ensureLoaderWorkerPool().then(async (pool2) => {
+  const { port1: mainPort, port2: workerPort } = new import_node_worker_threads.MessageChannel();
+  const { port1: mainSyncPort, port2: workerSyncPort } = new import_node_worker_threads.MessageChannel();
+  return new Promise((resolve2, reject) => {
+    const handleError = (error) => {
+      mainPort.close();
+      mainSyncPort.close();
+      reject(error);
+    };
+    const pendingRequests = /* @__PURE__ */ new Map();
+    mainPort.on("message", (message) => {
+      if (isWorkerDoneMessage(message)) {
+        Promise.allSettled(pendingRequests.values()).then((p) => {
+          mainPort.close();
+          mainSyncPort.close();
+          resolve2(message.data);
+        });
+      } else if (isWorkerDoneErrorMessage(message)) {
+        Promise.allSettled(pendingRequests.values()).then(() => {
+          mainPort.close();
+          mainSyncPort.close();
+          reject(message.error);
+        });
+      } else if (isWorkerRequestMessage(message)) {
+        pendingRequests.set(
+          message.id,
+          Promise.resolve().then(
+            () => options.handleIncomingRequest(
+              message.requestType,
+              ...message.data
+            )
+          ).then((result2) => {
+            mainPort.postMessage({
+              type: "response",
+              id: message.id,
+              data: result2
+            });
+            return result2;
+          }).catch((error) => {
+            mainPort.postMessage({
+              type: "response-error",
+              id: message.id,
+              error: serializeError(error)
+            });
+          })
+        );
+      }
+    });
+    mainPort.on("messageerror", handleError);
+    mainSyncPort.on("message", async (message) => {
+      const sharedBuffer = message.sharedBuffer;
+      const sharedBufferView = new Int32Array(sharedBuffer);
+      let result2;
+      try {
+        switch (message.requestType) {
+          case "WaitForPendingRequest" /* WaitForPendingRequest */: {
+            const pendingRequestId = message.data[0];
+            const ids = Array.isArray(pendingRequestId) ? pendingRequestId : [pendingRequestId];
+            result2 = await Promise.all(
+              ids.map((id) => pendingRequests.get(id))
+            );
+            break;
+          }
+          default:
+            throw new Error(`Unknown request type: ${message.requestType}`);
+        }
+        mainSyncPort.postMessage({
+          type: "response",
+          id: message.id,
+          data: result2
+        });
+      } catch (e) {
+        mainSyncPort.postMessage({
+          type: "response-error",
+          id: message.id,
+          error: serializeError(e)
+        });
+      }
+      Atomics.add(sharedBufferView, 0, 1);
+      Atomics.notify(sharedBufferView, 0, Number.POSITIVE_INFINITY);
+    });
+    mainSyncPort.on("messageerror", handleError);
+    pool2.run(
+      {
+        ...task,
+        // Internal worker data. Tinypool does not support passing `transferList` to
+        // `new Worker(..)`
+        workerData: {
+          workerPort,
+          workerSyncPort
+        }
+      },
+      {
+        ...options,
+        transferList: [
+          ...(options == null ? void 0 : options.transferList) || [],
+          workerPort,
+          workerSyncPort
+        ]
+      }
+    ).catch(handleError);
+  });
+});
+
+// src/loader-runner/utils.ts
+var import_node_util4 = require("util");
+
 // src/loader-runner/LoaderLoadingError.ts
 var LoadingLoaderError = class extends Error {
   constructor(message) {
@@ -5303,6 +5464,89 @@ function handleResult(loader2, module2, callback) {
   callback();
 }
 
+// src/loader-runner/utils.ts
+var decoder = new TextDecoder();
+function utf8BufferToString(buf) {
+  const str = decoder.decode(buf);
+  if (str.charCodeAt(0) === 65279) {
+    return str.slice(1);
+  }
+  return str;
+}
+function convertArgs(args, raw) {
+  if (!raw && args[0] instanceof Uint8Array)
+    args[0] = utf8BufferToString(args[0]);
+  else if (raw && typeof args[0] === "string")
+    args[0] = Buffer.from(args[0], "utf-8");
+  if (raw && args[0] instanceof Uint8Array && !Buffer.isBuffer(args[0])) {
+    args[0] = Buffer.from(args[0].buffer);
+  }
+}
+var loadLoader2 = (0, import_node_util4.promisify)(loadLoader);
+var runSyncOrAsync = (0, import_node_util4.promisify)(function runSyncOrAsync2(fn2, context2, args, callback) {
+  let isSync = true;
+  let isDone = false;
+  let isError = false;
+  let reportedError = false;
+  context2.async = function async() {
+    if (isDone) {
+      if (reportedError) return void 0;
+      throw new Error("async(): The callback was already called.");
+    }
+    isSync = false;
+    return innerCallback;
+  };
+  const innerCallback = (err, ...args2) => {
+    if (isDone) {
+      if (reportedError) return;
+      throw new Error("callback(): The callback was already called.");
+    }
+    isDone = true;
+    isSync = false;
+    try {
+      callback(err, args2);
+    } catch (e) {
+      isError = true;
+      throw e;
+    }
+  };
+  context2.callback = innerCallback;
+  try {
+    const result2 = function LOADER_EXECUTION() {
+      return fn2.apply(context2, args);
+    }();
+    if (isSync) {
+      isDone = true;
+      if (result2 === void 0) {
+        callback(null, []);
+        return;
+      }
+      if (result2 && typeof result2 === "object" && typeof result2.then === "function") {
+        result2.then((r) => {
+          callback(null, [r]);
+        }, callback);
+        return;
+      }
+      callback(null, [result2]);
+      return;
+    }
+  } catch (e) {
+    const err = e;
+    if ("hideStack" in err && err.hideStack) {
+      err.hideStack = "true";
+    }
+    if (isError) throw e;
+    if (isDone) {
+      if (e instanceof Error) console.error(e.stack);
+      else console.error(e);
+      return;
+    }
+    isDone = true;
+    reportedError = true;
+    callback(e, []);
+  }
+});
+
 // src/loader-runner/index.ts
 function createLoaderObject(loader2, compiler) {
   const obj = {
@@ -5357,11 +5601,10 @@ function createLoaderObject(loader2, compiler) {
   return obj;
 }
 var LoaderObject = class {
-  #loaderItem;
   constructor(loaderItem, compiler) {
     const {
       request,
-      path: path11,
+      path: path13,
       query,
       fragment,
       options,
@@ -5372,7 +5615,7 @@ var LoaderObject = class {
       type
     } = createLoaderObject(loaderItem, compiler);
     this.request = request;
-    this.path = path11;
+    this.path = path13;
     this.query = query;
     this.fragment = fragment;
     this.options = options;
@@ -5381,41 +5624,23 @@ var LoaderObject = class {
     this.pitch = pitch;
     this.raw = raw;
     this.type = type;
-    this.#loaderItem = loaderItem;
+    this.parallel = ident ? compiler.__internal__ruleSet.references.get(`${ident}$$parallelism`) : false;
+    this.loaderItem = loaderItem;
+    this.loaderItem.data = this.loaderItem.data ?? {};
   }
   get pitchExecuted() {
-    return this.#loaderItem.pitchExecuted;
+    return this.loaderItem.pitchExecuted;
   }
   set pitchExecuted(value) {
     (0, import_node_assert2.default)(value);
-    this.#loaderItem.pitchExecuted = true;
+    this.loaderItem.pitchExecuted = true;
   }
   get normalExecuted() {
-    return this.#loaderItem.normalExecuted;
+    return this.loaderItem.normalExecuted;
   }
   set normalExecuted(value) {
     (0, import_node_assert2.default)(value);
-    this.#loaderItem.normalExecuted = true;
-  }
-  // A data object shared between the pitch and the normal phase
-  get data() {
-    return new Proxy(this.#loaderItem.data = this.#loaderItem.data ?? {}, {
-      set: (_, property, value) => {
-        if (typeof property === "string") {
-          this.#loaderItem.data[property] = value;
-        }
-        return true;
-      },
-      get: (_, property) => {
-        if (typeof property === "string") {
-          return this.#loaderItem.data[property];
-        }
-      }
-    });
-  }
-  // A data object shared between the pitch and the normal phase
-  set data(data) {
-    this.#loaderItem.data = data;
+    this.loaderItem.normalExecuted = true;
   }
   shouldYield() {
     return this.request.startsWith(BUILTIN_LOADER_PREFIX);
@@ -5424,7 +5649,7 @@ var LoaderObject = class {
     return new this(loaderItem, compiler);
   }
   static __to_binding(loader2) {
-    return loader2.#loaderItem;
+    return loader2.loaderItem;
   }
 };
 var JsSourceMap = class {
@@ -5435,81 +5660,17 @@ var JsSourceMap = class {
     return serializeObject(map);
   }
 };
-var loadLoaderAsync = (0, import_node_util4.promisify)(loadLoader);
-var runSyncOrAsync = (0, import_node_util4.promisify)(function runSyncOrAsync2(fn2, context2, args, callback) {
-  let isSync = true;
-  let isDone = false;
-  let isError = false;
-  let reportedError = false;
-  context2.async = function async() {
-    if (isDone) {
-      if (reportedError) return void 0;
-      throw new Error("async(): The callback was already called.");
-    }
-    isSync = false;
-    return innerCallback;
-  };
-  const innerCallback = (err, ...args2) => {
-    if (isDone) {
-      if (reportedError) return;
-      throw new Error("callback(): The callback was already called.");
-    }
-    isDone = true;
-    isSync = false;
-    try {
-      callback(err, args2);
-    } catch (e) {
-      isError = true;
-      throw e;
-    }
-  };
-  context2.callback = innerCallback;
-  try {
-    const result2 = function LOADER_EXECUTION() {
-      return fn2.apply(context2, args);
-    }();
-    if (isSync) {
-      isDone = true;
-      if (result2 === void 0) {
-        callback(null, []);
-        return;
-      }
-      if (result2 && typeof result2 === "object" && typeof result2.then === "function") {
-        result2.then((r) => {
-          callback(null, [r]);
-        }, callback);
-        return;
-      }
-      callback(null, [result2]);
-      return;
-    }
-  } catch (e) {
-    const err = e;
-    if ("hideStack" in err && err.hideStack) {
-      err.hideStack = "true";
-    }
-    if (isError) throw e;
-    if (isDone) {
-      if (e instanceof Error) console.error(e.stack);
-      else console.error(e);
-      return;
-    }
-    isDone = true;
-    reportedError = true;
-    callback(e, []);
-  }
-});
-function dirname2(path11) {
-  if (path11 === "/") return "/";
-  const i = path11.lastIndexOf("/");
-  const j = path11.lastIndexOf("\\");
-  const i2 = path11.indexOf("/");
-  const j2 = path11.indexOf("\\");
+function dirname2(path13) {
+  if (path13 === "/") return "/";
+  const i = path13.lastIndexOf("/");
+  const j = path13.lastIndexOf("\\");
+  const i2 = path13.indexOf("/");
+  const j2 = path13.indexOf("\\");
   const idx = i > j ? i : j;
   const idx2 = i > j ? i2 : j2;
-  if (idx < 0) return path11;
-  if (idx === idx2) return path11.slice(0, idx + 1);
-  return path11.slice(0, idx);
+  if (idx < 0) return path13;
+  if (idx === idx2) return path13.slice(0, idx + 1);
+  return path13.slice(0, idx);
 }
 function getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
   var _a;
@@ -5559,7 +5720,6 @@ async function tryTrace(context2) {
   return null;
 }
 async function runLoaders(compiler, context2) {
-  var _a, _b;
   const { tracer, activeContext } = await tryTrace(context2) ?? {};
   const loaderState = context2.loaderState;
   const { resource } = context2.resourceData;
@@ -5910,48 +6070,228 @@ async function runLoaders(compiler, context2) {
   });
   Object.defineProperty(loaderContext, "data", {
     enumerable: true,
-    get: () => loaderContext.loaders[loaderContext.loaderIndex].data,
-    set: (data) => loaderContext.loaders[loaderContext.loaderIndex].data = data
+    get: () => loaderContext.loaders[loaderContext.loaderIndex].loaderItem.data,
+    set: (data) => loaderContext.loaders[loaderContext.loaderIndex].loaderItem.data = data
   });
   Object.defineProperty(loaderContext, "__internal__parseMeta", {
     enumerable: true,
     get: () => context2.__internal__parseMeta
   });
+  const getWorkerLoaderContext = () => {
+    const workerLoaderContext = {
+      hot: loaderContext.hot,
+      context: loaderContext.context,
+      resourcePath: loaderContext.resourcePath,
+      resourceQuery: loaderContext.resourceQuery,
+      resourceFragment: loaderContext.resourceFragment,
+      resource: loaderContext.resource,
+      mode: loaderContext.mode,
+      sourceMap: loaderContext.sourceMap,
+      rootContext: loaderContext.context,
+      loaderIndex: loaderContext.loaderIndex,
+      loaders: loaderContext.loaders.map((item) => {
+        return {
+          ...item,
+          pitch: void 0,
+          normal: void 0,
+          normalExecuted: item.normalExecuted,
+          pitchExecuted: item.pitchExecuted
+        };
+      }),
+      __internal__workerInfo: {
+        hashFunction: compiler._lastCompilation.outputOptions.hashFunction
+      },
+      _compiler: {
+        options: {
+          experiments: {
+            css: compiler.options.experiments.css
+          }
+        }
+      },
+      _compilation: {
+        outputOptions: compiler._lastCompilation.outputOptions
+      },
+      _module: {
+        type: loaderContext._module.type,
+        identifier: loaderContext._module.identifier()
+      }
+    };
+    Object.assign(workerLoaderContext, compiler.options.loader);
+    return workerLoaderContext;
+  };
+  const getWorkerLoaderHandlers = function() {
+    return {
+      handleIncomingRequest(requestType, ...args) {
+        switch (requestType) {
+          case "AddDependency" /* AddDependency */: {
+            loaderContext.addDependency(args[0]);
+            break;
+          }
+          case "AddContextDependency" /* AddContextDependency */: {
+            loaderContext.addContextDependency(args[0]);
+            break;
+          }
+          case "AddMissingDependency" /* AddMissingDependency */: {
+            loaderContext.addMissingDependency(args[0]);
+            break;
+          }
+          case "AddBuildDependency" /* AddBuildDependency */: {
+            loaderContext.addBuildDependency(args[0]);
+            break;
+          }
+          case "GetDependencies" /* GetDependencies */: {
+            return loaderContext.getDependencies();
+          }
+          case "GetContextDependencies" /* GetContextDependencies */: {
+            return loaderContext.getContextDependencies();
+          }
+          case "GetMissingDependencies" /* GetMissingDependencies */: {
+            return loaderContext.getMissingDependencies();
+          }
+          case "ClearDependencies" /* ClearDependencies */: {
+            loaderContext.clearDependencies();
+            break;
+          }
+          case "Resolve" /* Resolve */: {
+            return new Promise((resolve2, reject) => {
+              loaderContext.resolve(args[0], args[1], (err, result2) => {
+                if (err) reject(err);
+                else resolve2(result2);
+              });
+            });
+          }
+          case "GetResolve" /* GetResolve */: {
+            return new Promise((resolve2, reject) => {
+              loaderContext.getResolve(args[0])(
+                args[1],
+                args[2],
+                (err, result2) => {
+                  if (err) reject(err);
+                  else resolve2(result2);
+                }
+              );
+            });
+          }
+          case "GetLogger" /* GetLogger */: {
+            const [type, name2, arg] = args;
+            loaderContext.getLogger(name2)[type](...arg);
+          }
+          case "EmitError" /* EmitError */: {
+            const workerError = args[0];
+            const error = new Error(workerError.message);
+            error.stack = workerError.stack;
+            error.name = workerError.name;
+            loaderContext.emitError(error);
+            break;
+          }
+          case "EmitWarning" /* EmitWarning */: {
+            const workerError = args[0];
+            const error = new Error(workerError.message);
+            error.stack = workerError.stack;
+            error.name = workerError.name;
+            loaderContext.emitWarning(error);
+            break;
+          }
+          case "EmitFile" /* EmitFile */: {
+            const [name2, content, sourceMap, assetInfo] = args;
+            loaderContext.emitFile(name2, content, sourceMap, assetInfo);
+            break;
+          }
+          case "EmitDiagnostic" /* EmitDiagnostic */: {
+            const diagnostic = args[0];
+            loaderContext.experiments.emitDiagnostic(diagnostic);
+            break;
+          }
+          case "SetCacheable" /* SetCacheable */: {
+            const cacheable = args[0];
+            loaderContext.cacheable(cacheable);
+            break;
+          }
+          case "UpdateLoaderObjects" /* UpdateLoaderObjects */: {
+            const updates = args[0];
+            loaderContext.loaders = loaderContext.loaders.map((item, index) => {
+              const update = updates[index];
+              item.loaderItem.data = update.data;
+              if (update.pitchExecuted) {
+                item.pitchExecuted = true;
+              }
+              if (update.normalExecuted) {
+                item.normalExecuted = true;
+              }
+              return item;
+            });
+            break;
+          }
+          default: {
+            throw new Error(`Unknown request type: ${requestType}`);
+          }
+        }
+      }
+    };
+  };
+  const enableParallelism = (currentLoaderObject) => {
+    return compiler.options.experiments.parallelLoader && (currentLoaderObject == null ? void 0 : currentLoaderObject.parallel);
+  };
+  const isomorphoicRun = async (fn2, args) => {
+    const currentLoaderObject = getCurrentLoader(loaderContext);
+    const parallelism = enableParallelism(currentLoaderObject);
+    const pitch = loaderState === import_binding3.JsLoaderState.Pitching;
+    const worker2 = parallelism;
+    let result2;
+    const span = tracer == null ? void 0 : tracer.startSpan(
+      `LoaderRunner:${pitch ? "pitch" : "normal"}${worker2 ? " (worker)" : ""}`,
+      {
+        attributes: {
+          "loader.identifier": currentLoaderObject == null ? void 0 : currentLoaderObject.request
+        }
+      },
+      activeContext
+    );
+    if (parallelism) {
+      result2 = await run(
+        {
+          loaderContext: getWorkerLoaderContext(),
+          loaderState,
+          args
+        },
+        getWorkerLoaderHandlers()
+      ) || [];
+    } else {
+      if (loaderState === import_binding3.JsLoaderState.Normal)
+        convertArgs(args, !!(currentLoaderObject == null ? void 0 : currentLoaderObject.raw));
+      result2 = await runSyncOrAsync(fn2, loaderContext, args) || [];
+    }
+    span == null ? void 0 : span.end();
+    return result2;
+  };
   try {
     switch (loaderState) {
       case import_binding3.JsLoaderState.Pitching: {
         while (loaderContext.loaderIndex < loaderContext.loaders.length) {
           const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+          const parallelism = enableParallelism(currentLoaderObject);
           if (currentLoaderObject.shouldYield()) break;
           if (currentLoaderObject.pitchExecuted) {
             loaderContext.loaderIndex += 1;
             continue;
           }
-          await loadLoaderAsync(currentLoaderObject);
+          await loadLoader2(currentLoaderObject);
           const fn2 = currentLoaderObject.pitch;
-          currentLoaderObject.pitchExecuted = true;
+          if (!parallelism || !fn2) {
+            currentLoaderObject.pitchExecuted = true;
+          }
           if (!fn2) continue;
-          const span = tracer == null ? void 0 : tracer.startSpan(
-            "LoaderRunner:pitch",
-            {
-              attributes: {
-                "loader.identifier": (_a = getCurrentLoader(loaderContext)) == null ? void 0 : _a.request
-              }
-            },
-            activeContext
-          );
-          const args = await runSyncOrAsync(fn2, loaderContext, [
+          const args = await isomorphoicRun(fn2, [
             loaderContext.remainingRequest,
             loaderContext.previousRequest,
-            currentLoaderObject.data
-          ]) || [];
-          span == null ? void 0 : span.end();
+            currentLoaderObject.loaderItem.data
+          ]);
           const hasArg = args.some((value) => value !== void 0);
           if (hasArg) {
             const [content, sourceMap, additionalData] = args;
             context2.content = isNil(content) ? null : toBuffer(content);
             context2.sourceMap = serializeObject(sourceMap);
-            context2.additionalData = additionalData;
+            context2.additionalData = additionalData || void 0;
             break;
           }
         }
@@ -5963,28 +6303,23 @@ async function runLoaders(compiler, context2) {
         let additionalData = context2.additionalData;
         while (loaderContext.loaderIndex >= 0) {
           const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+          const parallelism = enableParallelism(currentLoaderObject);
           if (currentLoaderObject.shouldYield()) break;
           if (currentLoaderObject.normalExecuted) {
             loaderContext.loaderIndex--;
             continue;
           }
-          await loadLoaderAsync(currentLoaderObject);
+          await loadLoader2(currentLoaderObject);
           const fn2 = currentLoaderObject.normal;
-          currentLoaderObject.normalExecuted = true;
+          if (!parallelism || !fn2) {
+            currentLoaderObject.normalExecuted = true;
+          }
           if (!fn2) continue;
-          const args = [content, sourceMap, additionalData];
-          convertArgs(args, !!currentLoaderObject.raw);
-          const span = tracer == null ? void 0 : tracer.startSpan(
-            "LoaderRunner:normal",
-            {
-              attributes: {
-                "loader.identifier": (_b = getCurrentLoader(loaderContext)) == null ? void 0 : _b.request
-              }
-            },
-            activeContext
-          );
-          [content, sourceMap, additionalData] = await runSyncOrAsync(fn2, loaderContext, args) || [];
-          span == null ? void 0 : span.end();
+          [content, sourceMap, additionalData] = await isomorphoicRun(fn2, [
+            content,
+            sourceMap,
+            additionalData
+          ]);
         }
         context2.content = isNil(content) ? null : toBuffer(content);
         context2.sourceMap = JsSourceMap.__to_binding(sourceMap);
@@ -6011,18 +6346,6 @@ async function runLoaders(compiler, context2) {
   }
   return context2;
 }
-function utf8BufferToString(buf) {
-  const str = buf.toString("utf-8");
-  if (str.charCodeAt(0) === 65279) {
-    return str.slice(1);
-  }
-  return str;
-}
-function convertArgs(args, raw) {
-  if (!raw && Buffer.isBuffer(args[0])) args[0] = utf8BufferToString(args[0]);
-  else if (raw && typeof args[0] === "string")
-    args[0] = Buffer.from(args[0], "utf-8");
-}
 var PATH_QUERY_FRAGMENT_REGEXP2 = /^((?:\u200b.|[^?#\u200b])*)(\?(?:\u200b.|[^#\u200b])*)?(#.*)?$/;
 function parsePathQueryFragment(str) {
   const match = PATH_QUERY_FRAGMENT_REGEXP2.exec(str);
@@ -6035,10 +6358,10 @@ function parsePathQueryFragment(str) {
 
 // src/config/adapterRuleUse.ts
 var BUILTIN_LOADER_PREFIX = "builtin:";
-function createRawModuleRuleUses(uses, path11, options) {
+function createRawModuleRuleUses(uses, path13, options) {
   const normalizeRuleSetUseItem = (item) => typeof item === "string" ? { loader: item } : item;
   const allUses = Array.isArray(uses) ? [...uses].map(normalizeRuleSetUseItem) : [normalizeRuleSetUseItem(uses)];
-  return createRawModuleRuleUsesImpl(allUses, path11, options);
+  return createRawModuleRuleUsesImpl(allUses, path13, options);
 }
 var getSwcLoaderOptions = (options, _) => {
   if (options && typeof options === "object") {
@@ -6079,7 +6402,7 @@ function getBuiltinLoaderOptions(identifier, o, options) {
   }
   return o;
 }
-function createRawModuleRuleUsesImpl(uses, path11, options) {
+function createRawModuleRuleUsesImpl(uses, path13, options) {
   if (!uses.length) {
     return [];
   }
@@ -6094,7 +6417,7 @@ function createRawModuleRuleUsesImpl(uses, path11, options) {
     return {
       loader: resolveStringifyLoaders(
         use,
-        `${path11}[${index}]`,
+        `${path13}[${index}]`,
         options.compiler,
         isBuiltin
       ),
@@ -6102,20 +6425,33 @@ function createRawModuleRuleUsesImpl(uses, path11, options) {
     };
   });
 }
-function resolveStringifyLoaders(use, path11, compiler, isBuiltin) {
+function resolveStringifyLoaders(use, path13, compiler, isBuiltin) {
   const obj = parsePathQueryFragment(use.loader);
-  let ident = null;
+  let ident = use.ident;
   if (use.options === null) {
   } else if (use.options === void 0) {
   } else if (typeof use.options === "string") obj.query = `?${use.options}`;
   else if (use.ident) obj.query = `??${ident = use.ident}`;
   else if (typeof use.options === "object" && use.options.ident)
     obj.query = `??${ident = use.options.ident}`;
-  else if (typeof use.options === "object") obj.query = `??${ident = path11}`;
+  else if (typeof use.options === "object") obj.query = `??${ident = path13}`;
   else obj.query = `?${JSON.stringify(use.options)}`;
+  const parallelism = !!use.parallel;
+  if (parallelism && (!use.options || typeof use.options !== "object")) {
+    throw new Error(
+      `\`Rule.use.parallel\` requires \`Rule.use.options\` to be an object.
+However the received value is \`${use.options}\` under option path \`${path13}\`
+Internally, parallelism is provided by passing \`Rule.use.ident\` to the loader as an identifier to ident the parallelism option
+You can either replace the \`Rule.use.loader\` with \`Rule.use.options = {}\` or remove \`Rule.use.parallel\`.`
+    );
+  }
   if (use.options && typeof use.options === "object") {
     if (!ident) ident = "[[missing ident]]";
     compiler.__internal__ruleSet.references.set(ident, use.options);
+    compiler.__internal__ruleSet.references.set(
+      `${ident}$$parallelism`,
+      parallelism
+    );
     if (isBuiltin) {
       compiler.__internal__ruleSet.builtinReferences.set(ident, use.options);
     }
@@ -6198,10 +6534,13 @@ function getRawExtensionAlias(alias = {}) {
   return Object.fromEntries(entries);
 }
 function getRawAlias(alias = {}) {
-  return Object.entries(alias).map(([key, value]) => ({
-    path: key,
-    redirect: Array.isArray(value) ? value : [value]
-  }));
+  if (typeof alias === "object" && alias !== null && !Array.isArray(alias)) {
+    return Object.entries(alias).map(([key, value]) => ({
+      path: key,
+      redirect: Array.isArray(value) ? value : [value]
+    }));
+  }
+  return false;
 }
 function getRawResolveByDependency(byDependency) {
   if (byDependency === void 0) return byDependency;
@@ -6277,7 +6616,7 @@ function tryMatch(payload, condition) {
   }
   return false;
 }
-var getRawModuleRule = (rule, path11, options, upperType) => {
+var getRawModuleRule = (rule, path13, options, upperType) => {
   if (rule.loader) {
     rule.use = [
       {
@@ -6295,7 +6634,7 @@ var getRawModuleRule = (rule, path11, options, upperType) => {
         compiler: options.compiler
       };
       const uses = use(context2);
-      return createRawModuleRuleUses(uses ?? [], `${path11}.use`, options);
+      return createRawModuleRuleUses(uses ?? [], `${path13}.use`, options);
     };
   }
   const rawModuleRule = {
@@ -6323,7 +6662,7 @@ var getRawModuleRule = (rule, path11, options, upperType) => {
     scheme: rule.scheme ? getRawRuleSetCondition(rule.scheme) : void 0,
     mimetype: rule.mimetype ? getRawRuleSetCondition(rule.mimetype) : void 0,
     sideEffects: rule.sideEffects,
-    use: typeof rule.use === "function" ? funcUse : createRawModuleRuleUses(rule.use ?? [], `${path11}.use`, options),
+    use: typeof rule.use === "function" ? funcUse : createRawModuleRuleUses(rule.use ?? [], `${path13}.use`, options),
     type: rule.type,
     layer: rule.layer,
     parser: rule.parser ? getRawParserOptions(rule.parser, rule.type ?? upperType) : void 0,
@@ -6332,7 +6671,7 @@ var getRawModuleRule = (rule, path11, options, upperType) => {
     oneOf: rule.oneOf ? rule.oneOf.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
-        `${path11}.oneOf[${index}]`,
+        `${path13}.oneOf[${index}]`,
         options,
         rule2.type ?? upperType
       )
@@ -6340,7 +6679,7 @@ var getRawModuleRule = (rule, path11, options, upperType) => {
     rules: rule.rules ? rule.rules.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
-        `${path11}.rules[${index}]`,
+        `${path13}.rules[${index}]`,
         options,
         rule2.type ?? upperType
       )
@@ -6354,11 +6693,11 @@ var getRawModuleRule = (rule, path11, options, upperType) => {
     delete rawModuleRule.resourceFragment;
     rawModuleRule.rspackResource = getRawRuleSetCondition(
       (resourceQueryFragment) => {
-        const { path: path12, query, fragment } = parseResource(resourceQueryFragment);
-        if (rule.test && !tryMatch(path12, rule.test)) {
+        const { path: path14, query, fragment } = parseResource(resourceQueryFragment);
+        if (rule.test && !tryMatch(path14, rule.test)) {
           return false;
         }
-        if (rule.resource && !tryMatch(path12, rule.resource)) {
+        if (rule.resource && !tryMatch(path14, rule.resource)) {
           return false;
         }
         if (rule.resourceQuery && !tryMatch(query, rule.resourceQuery)) {
@@ -6480,7 +6819,7 @@ function getRawParserOptions(parser, type) {
       json: getRawJsonParserOptions(parser)
     };
   }
-  throw new Error(`unreachable: unknow module type: ${type}`);
+  throw new Error(`unreachable: unknown module type: ${type}`);
 }
 function getRawJavascriptParserOptions(parser) {
   var _a, _b, _c;
@@ -6668,7 +7007,7 @@ function getRawStats(stats) {
 // src/config/defaults.ts
 var import_node_assert6 = __toESM(require("assert"));
 var import_node_fs3 = __toESM(require("fs"));
-var import_node_path9 = __toESM(require("path"));
+var import_node_path11 = __toESM(require("path"));
 
 // src/ModuleTypeConstants.ts
 var JSON_MODULE_TYPE = "json";
@@ -7019,13 +7358,13 @@ var CopyRspackPlugin = create2(
 
 // src/builtin-plugin/css-extract/index.ts
 var import_binding15 = require("@rspack/binding");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 
 // src/builtin-plugin/css-extract/loader.ts
-var import_node_path4 = __toESM(require("path"));
+var import_node_path5 = __toESM(require("path"));
 
 // src/builtin-plugin/css-extract/utils.ts
-var import_node_path3 = __toESM(require("path"));
+var import_node_path4 = __toESM(require("path"));
 var PLUGIN_NAME = "css-extract-rspack-plugin";
 
 // src/builtin-plugin/css-extract/loader.ts
@@ -7035,7 +7374,7 @@ var ABSOLUTE_PUBLIC_PATH = `${BASE_URI}/mini-css-extract-plugin/`;
 
 // src/builtin-plugin/css-extract/index.ts
 var DEFAULT_FILENAME = "[name].css";
-var LOADER_PATH = (0, import_node_path5.join)(__dirname, "cssExtractLoader.js");
+var LOADER_PATH = (0, import_node_path6.join)(__dirname, "cssExtractLoader.js");
 var CssExtractRspackPlugin = class {
   constructor(options) {
     this.options = options || {};
@@ -7534,38 +7873,36 @@ function getRawExternalItem(compiler, item) {
               issuer: data.contextInfo.issuer,
               issuerLayer: data.contextInfo.issuerLayer ?? null
             },
-            getResolve: function getResolve(options) {
+            getResolve: (options) => (context2, request, callback) => {
               const resolver = new Resolver(ctx.getResolver());
+              const child = options ? resolver.withOptions(options) : resolver;
               const getResolveContext = () => ({
                 fileDependencies: compiler._lastCompilation.fileDependencies,
                 missingDependencies: compiler._lastCompilation.missingDependencies,
                 contextDependencies: compiler._lastCompilation.contextDependencies
               });
-              const child = options ? resolver.withOptions(options) : resolver;
-              return (context2, request, callback) => {
-                if (callback) {
+              if (callback) {
+                child.resolve(
+                  {},
+                  context2,
+                  request,
+                  getResolveContext(),
+                  callback
+                );
+              } else {
+                return new Promise((resolve3, reject2) => {
                   child.resolve(
                     {},
                     context2,
                     request,
                     getResolveContext(),
-                    callback
+                    (err, result2) => {
+                      if (err) reject2(err);
+                      else resolve3(result2);
+                    }
                   );
-                } else {
-                  return new Promise((resolve3, reject2) => {
-                    child.resolve(
-                      {},
-                      context2,
-                      request,
-                      getResolveContext(),
-                      (err, result2) => {
-                        if (err) reject2(err);
-                        else resolve3(result2);
-                      }
-                    );
-                  });
-                }
-              };
+                });
+              }
             }
           },
           (err, result2, type) => {
@@ -7685,18 +8022,14 @@ var HotModuleReplacementPlugin = class extends RspackBuiltinPlugin {
 
 // src/builtin-plugin/html-plugin/plugin.ts
 var import_node_fs = __toESM(require("fs"));
-var import_node_path6 = __toESM(require("path"));
+var import_node_path7 = __toESM(require("path"));
 var import_binding35 = require("@rspack/binding");
 
 // src/builtin-plugin/html-plugin/hooks.ts
 var liteTapable5 = __toESM(require("@rspack/lite-tapable"));
 var compilationHooksMap2 = /* @__PURE__ */ new WeakMap();
 var getPluginHooks = (compilation) => {
-  if (!(compilation instanceof Compilation)) {
-    throw new TypeError(
-      "The 'compilation' argument must be an instance of Compilation"
-    );
-  }
+  checkCompilation(compilation);
   let hooks = compilationHooksMap2.get(compilation);
   if (hooks === void 0) {
     hooks = {
@@ -7753,11 +8086,11 @@ function isNonEmptyArray(value) {
   return value.length !== 0;
 }
 var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
-function joinPath(path11) {
-  if (path11.length === 1) {
-    return path11[0].toString();
+function joinPath(path13) {
+  if (path13.length === 1) {
+    return path13[0].toString();
   }
-  return path11.reduce((acc, item) => {
+  return path13.reduce((acc, item) => {
     if (typeof item === "number") {
       return acc + "[" + item.toString() + "]";
     }
@@ -8107,10 +8440,10 @@ var HtmlRspackPluginImpl = create2(
       templateContent = "";
     } else if (c.template) {
       const filename2 = c.template.split("?")[0];
-      if ([".js", ".cjs"].includes(import_node_path6.default.extname(filename2))) {
+      if ([".js", ".cjs"].includes(import_node_path7.default.extname(filename2))) {
         templateFn = async (data) => {
           const context2 = this.options.context || process.cwd();
-          const templateFilePath = import_node_path6.default.resolve(context2, filename2);
+          const templateFilePath = import_node_path7.default.resolve(context2, filename2);
           if (!import_node_fs.default.existsSync(templateFilePath)) {
             throw new Error(
               `HtmlRspackPlugin: could not load file \`${filename2}\` from \`${context2}\``
@@ -8246,8 +8579,53 @@ var HttpExternalsRspackPlugin = create2(
   }
 );
 
-// src/builtin-plugin/IgnorePlugin.ts
+// src/builtin-plugin/HttpUriPlugin.ts
+var import_node_path8 = __toESM(require("path"));
 var import_binding37 = require("@rspack/binding");
+var defaultHttpClient = (url2, headers) => {
+  return fetch(url2, { headers }).then((response) => {
+    return response.arrayBuffer().then((buffer) => {
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      return {
+        status: response.status,
+        headers: responseHeaders,
+        body: Buffer.from(buffer)
+      };
+    });
+  });
+};
+var HttpUriPlugin = class extends RspackBuiltinPlugin {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.name = import_binding37.BuiltinPluginName.HttpUriPlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const { options } = this;
+    const lockfileLocation = options.lockfileLocation ?? import_node_path8.default.join(
+      compiler.context,
+      compiler.name ? `${compiler.name}.rspack.lock` : "rspack.lock"
+    );
+    const cacheLocation = options.cacheLocation === false ? void 0 : options.cacheLocation ?? `${lockfileLocation}.data`;
+    const raw = {
+      allowedUris: options.allowedUris,
+      lockfileLocation,
+      cacheLocation,
+      upgrade: options.upgrade ?? false,
+      // frozen: options.frozen,
+      // proxy: options.proxy,
+      httpClient: options.httpClient ?? defaultHttpClient
+    };
+    return createBuiltinPlugin(this.name, raw);
+  }
+};
+
+// src/builtin-plugin/IgnorePlugin.ts
+var import_binding38 = require("@rspack/binding");
 var import_zod2 = require("../compiled/zod/index.js");
 var IgnorePluginOptions = import_zod2.z.union([
   import_zod2.z.object({
@@ -8259,7 +8637,7 @@ var IgnorePluginOptions = import_zod2.z.union([
   })
 ]);
 var IgnorePlugin = create2(
-  import_binding37.BuiltinPluginName.IgnorePlugin,
+  import_binding38.BuiltinPluginName.IgnorePlugin,
   (options) => {
     validate(options, IgnorePluginOptions);
     return options;
@@ -8267,33 +8645,29 @@ var IgnorePlugin = create2(
 );
 
 // src/builtin-plugin/InferAsyncModulesPlugin.ts
-var import_binding38 = require("@rspack/binding");
+var import_binding39 = require("@rspack/binding");
 var InferAsyncModulesPlugin = create2(
-  import_binding38.BuiltinPluginName.InferAsyncModulesPlugin,
+  import_binding39.BuiltinPluginName.InferAsyncModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/JavascriptModulesPlugin.ts
-var import_binding39 = require("@rspack/binding");
+var import_binding40 = require("@rspack/binding");
 var liteTapable6 = __toESM(require("@rspack/lite-tapable"));
 var compilationHooksMap3 = /* @__PURE__ */ new WeakMap();
 var JavascriptModulesPlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding39.BuiltinPluginName.JavascriptModulesPlugin;
+    this.name = import_binding40.BuiltinPluginName.JavascriptModulesPlugin;
     this.affectedHooks = "compilation";
   }
   raw() {
     return createBuiltinPlugin(this.name, void 0);
   }
   static getCompilationHooks(compilation) {
-    if (!(compilation instanceof Compilation)) {
-      throw new TypeError(
-        "The 'compilation' argument must be an instance of Compilation"
-      );
-    }
+    checkCompilation(compilation);
     let hooks = compilationHooksMap3.get(compilation);
     if (hooks === void 0) {
       hooks = {
@@ -8306,27 +8680,27 @@ var JavascriptModulesPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/JsLoaderRspackPlugin.ts
-var import_binding40 = require("@rspack/binding");
+var import_binding41 = require("@rspack/binding");
 var JsLoaderRspackPlugin = create2(
-  import_binding40.BuiltinPluginName.JsLoaderRspackPlugin,
+  import_binding41.BuiltinPluginName.JsLoaderRspackPlugin,
   (compiler) => runLoaders.bind(null, compiler),
   /* Not Inheretable */
   "thisCompilation"
 );
 
 // src/builtin-plugin/JsonModulesPlugin.ts
-var import_binding41 = require("@rspack/binding");
+var import_binding42 = require("@rspack/binding");
 var JsonModulesPlugin = create2(
-  import_binding41.BuiltinPluginName.JsonModulesPlugin,
+  import_binding42.BuiltinPluginName.JsonModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/lazy-compilation/lazyCompilation.ts
-var import_binding42 = require("@rspack/binding");
+var import_binding43 = require("@rspack/binding");
 var BuiltinLazyCompilationPlugin = create2(
-  import_binding42.BuiltinPluginName.LazyCompilationPlugin,
+  import_binding43.BuiltinPluginName.LazyCompilationPlugin,
   (module2, cacheable, entries, imports, test) => ({ module: module2, cacheable, imports, entries, test }),
   "thisCompilation"
 );
@@ -8347,11 +8721,11 @@ var lazyCompilationMiddleware = (compiler, userOptions = {}) => {
   const activeModules = /* @__PURE__ */ new Map();
   const filesByKey = /* @__PURE__ */ new Map();
   new BuiltinLazyCompilationPlugin(
-    ({ module: module2, path: path11 }) => {
+    ({ module: module2, path: path13 }) => {
       const key = encodeURIComponent(
         module2.replace(/\\/g, "/").replace(/@/g, "_")
       ).replace(/%(2F|3A|24|26|2B|2C|3B|3D)/g, decodeURIComponent);
-      filesByKey.set(key, path11);
+      filesByKey.set(key, path13);
       const active = activeModules.get(key) === true;
       return {
         client: `${options.client || getDefaultClient(compiler)}?${encodeURIComponent((options.serverUrl ?? "") + LAZY_COMPILATION_PREFIX)}`,
@@ -8402,28 +8776,30 @@ var lazyCompilationMiddlewareInternal = (compiler, activeModules, filesByKey) =>
         }).filter(Boolean)
       );
       if (rebuiltModules.size) {
-        compiler.watching.invalidateWithChangedFiles(new Set(rebuiltModules));
+        compiler.watching.invalidateWithChangesAndRemovals(
+          new Set(rebuiltModules)
+        );
       }
     }
   };
 };
 
 // src/builtin-plugin/LimitChunkCountPlugin.ts
-var import_binding43 = require("@rspack/binding");
+var import_binding44 = require("@rspack/binding");
 var LimitChunkCountPlugin = create2(
-  import_binding43.BuiltinPluginName.LimitChunkCountPlugin,
+  import_binding44.BuiltinPluginName.LimitChunkCountPlugin,
   (options) => {
     return options;
   }
 );
 
 // src/builtin-plugin/MangleExportsPlugin.ts
-var import_binding44 = require("@rspack/binding");
+var import_binding45 = require("@rspack/binding");
 var MangleExportsPlugin = class extends RspackBuiltinPlugin {
   constructor(deterministic) {
     super();
     this.deterministic = deterministic;
-    this.name = import_binding44.BuiltinPluginName.MangleExportsPlugin;
+    this.name = import_binding45.BuiltinPluginName.MangleExportsPlugin;
     this.affectedHooks = "compilation";
   }
   raw(compiler) {
@@ -8454,27 +8830,27 @@ var MangleExportsPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/MergeDuplicateChunksPlugin.ts
-var import_binding45 = require("@rspack/binding");
+var import_binding46 = require("@rspack/binding");
 var MergeDuplicateChunksPlugin = create2(
-  import_binding45.BuiltinPluginName.MergeDuplicateChunksPlugin,
+  import_binding46.BuiltinPluginName.MergeDuplicateChunksPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/ModuleChunkFormatPlugin.ts
-var import_binding46 = require("@rspack/binding");
+var import_binding47 = require("@rspack/binding");
 var ModuleChunkFormatPlugin = create2(
-  import_binding46.BuiltinPluginName.ModuleChunkFormatPlugin,
+  import_binding47.BuiltinPluginName.ModuleChunkFormatPlugin,
   () => {
   }
 );
 
 // src/builtin-plugin/ModuleConcatenationPlugin.ts
-var import_binding47 = require("@rspack/binding");
+var import_binding48 = require("@rspack/binding");
 var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding47.BuiltinPluginName.ModuleConcatenationPlugin;
+    this.name = import_binding48.BuiltinPluginName.ModuleConcatenationPlugin;
     this.affectedHooks = "compilation";
   }
   raw(compiler) {
@@ -8529,29 +8905,29 @@ var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/NamedChunkIdsPlugin.ts
-var import_binding48 = require("@rspack/binding");
+var import_binding49 = require("@rspack/binding");
 var NamedChunkIdsPlugin = create2(
-  import_binding48.BuiltinPluginName.NamedChunkIdsPlugin,
+  import_binding49.BuiltinPluginName.NamedChunkIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/NamedModuleIdsPlugin.ts
-var import_binding49 = require("@rspack/binding");
+var import_binding50 = require("@rspack/binding");
 var NamedModuleIdsPlugin = create2(
-  import_binding49.BuiltinPluginName.NamedModuleIdsPlugin,
+  import_binding50.BuiltinPluginName.NamedModuleIdsPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/NaturalChunkIdsPlugin.ts
-var import_binding50 = require("@rspack/binding");
+var import_binding51 = require("@rspack/binding");
 var NaturalChunkIdsPlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding50.BuiltinPluginName.NaturalChunkIdsPlugin;
+    this.name = import_binding51.BuiltinPluginName.NaturalChunkIdsPlugin;
     this.affectedHooks = "compilation";
   }
   raw(compiler) {
@@ -8570,11 +8946,11 @@ var NaturalChunkIdsPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/NaturalModuleIdsPlugin.ts
-var import_binding51 = require("@rspack/binding");
+var import_binding52 = require("@rspack/binding");
 var NaturalModuleIdsPlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding51.BuiltinPluginName.NaturalModuleIdsPlugin;
+    this.name = import_binding52.BuiltinPluginName.NaturalModuleIdsPlugin;
     this.affectedHooks = "compilation";
   }
   raw(compiler) {
@@ -8593,24 +8969,24 @@ var NaturalModuleIdsPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/NodeTargetPlugin.ts
-var import_binding52 = require("@rspack/binding");
+var import_binding53 = require("@rspack/binding");
 var NodeTargetPlugin = create2(
-  import_binding52.BuiltinPluginName.NodeTargetPlugin,
+  import_binding53.BuiltinPluginName.NodeTargetPlugin,
   () => void 0
 );
 
 // src/builtin-plugin/OccurrenceChunkIdsPlugin.ts
-var import_binding53 = require("@rspack/binding");
+var import_binding54 = require("@rspack/binding");
 var OccurrenceChunkIdsPlugin = create2(
-  import_binding53.BuiltinPluginName.OccurrenceChunkIdsPlugin,
+  import_binding54.BuiltinPluginName.OccurrenceChunkIdsPlugin,
   (options) => ({ ...options }),
   "compilation"
 );
 
 // src/builtin-plugin/ProgressPlugin.ts
-var import_binding54 = require("@rspack/binding");
+var import_binding55 = require("@rspack/binding");
 var ProgressPlugin = create2(
-  import_binding54.BuiltinPluginName.ProgressPlugin,
+  import_binding55.BuiltinPluginName.ProgressPlugin,
   (progress = {}) => {
     if (typeof progress === "function") {
       return {
@@ -8624,9 +9000,9 @@ var ProgressPlugin = create2(
 );
 
 // src/builtin-plugin/ProvidePlugin.ts
-var import_binding55 = require("@rspack/binding");
+var import_binding56 = require("@rspack/binding");
 var ProvidePlugin = create2(
-  import_binding55.BuiltinPluginName.ProvidePlugin,
+  import_binding56.BuiltinPluginName.ProvidePlugin,
   (provide) => {
     const entries = Object.entries(provide).map(([key, value]) => {
       if (typeof value === "string") {
@@ -8640,27 +9016,27 @@ var ProvidePlugin = create2(
 );
 
 // src/builtin-plugin/RealContentHashPlugin.ts
-var import_binding56 = require("@rspack/binding");
+var import_binding57 = require("@rspack/binding");
 var RealContentHashPlugin = create2(
-  import_binding56.BuiltinPluginName.RealContentHashPlugin,
+  import_binding57.BuiltinPluginName.RealContentHashPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/RemoveEmptyChunksPlugin.ts
-var import_binding57 = require("@rspack/binding");
+var import_binding58 = require("@rspack/binding");
 var RemoveEmptyChunksPlugin = create2(
-  import_binding57.BuiltinPluginName.RemoveEmptyChunksPlugin,
+  import_binding58.BuiltinPluginName.RemoveEmptyChunksPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/RuntimeChunkPlugin.ts
-var import_binding58 = require("@rspack/binding");
+var import_binding59 = require("@rspack/binding");
 var RuntimeChunkPlugin = create2(
-  import_binding58.BuiltinPluginName.RuntimeChunkPlugin,
+  import_binding59.BuiltinPluginName.RuntimeChunkPlugin,
   (options) => options,
   "thisCompilation"
 );
@@ -8677,11 +9053,7 @@ var RuntimePluginImpl = create2(
 var RuntimePlugin = RuntimePluginImpl;
 var compilationHooksMap4 = /* @__PURE__ */ new WeakMap();
 RuntimePlugin.getHooks = RuntimePlugin.getCompilationHooks = (compilation) => {
-  if (!(compilation instanceof Compilation)) {
-    throw new TypeError(
-      "The 'compilation' argument must be an instance of Compilation"
-    );
-  }
+  checkCompilation(compilation);
   let hooks = compilationHooksMap4.get(compilation);
   if (hooks === void 0) {
     hooks = {
@@ -8738,18 +9110,18 @@ var createRuntimePluginHooksRegisters = (getCompiler, createTap, createMapTap) =
 };
 
 // src/builtin-plugin/SideEffectsFlagPlugin.ts
-var import_binding59 = require("@rspack/binding");
+var import_binding60 = require("@rspack/binding");
 var SideEffectsFlagPlugin = create2(
-  import_binding59.BuiltinPluginName.SideEffectsFlagPlugin,
+  import_binding60.BuiltinPluginName.SideEffectsFlagPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/SizeLimitsPlugin.ts
-var import_binding60 = require("@rspack/binding");
+var import_binding61 = require("@rspack/binding");
 var SizeLimitsPlugin = create2(
-  import_binding60.BuiltinPluginName.SizeLimitsPlugin,
+  import_binding61.BuiltinPluginName.SizeLimitsPlugin,
   (options) => {
     const hints = options.hints === false ? void 0 : options.hints;
     return { ...options, hints };
@@ -8757,16 +9129,16 @@ var SizeLimitsPlugin = create2(
 );
 
 // src/builtin-plugin/SourceMapDevToolPlugin.ts
-var import_binding61 = require("@rspack/binding");
+var import_binding62 = require("@rspack/binding");
 var SourceMapDevToolPlugin = create2(
-  import_binding61.BuiltinPluginName.SourceMapDevToolPlugin,
+  import_binding62.BuiltinPluginName.SourceMapDevToolPlugin,
   (options) => options,
   "compilation"
 );
 
 // src/builtin-plugin/SplitChunksPlugin.ts
 var import_node_assert5 = __toESM(require("assert"));
-var import_binding62 = require("@rspack/binding");
+var import_binding63 = require("@rspack/binding");
 
 // src/util/SplitChunkSize.ts
 var JsSplitChunkSizes = class {
@@ -8789,7 +9161,7 @@ var SplitChunksPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
     this.options = options;
-    this.name = import_binding62.BuiltinPluginName.SplitChunksPlugin;
+    this.name = import_binding63.BuiltinPluginName.SplitChunksPlugin;
     this.affectedHooks = "thisCompilation";
   }
   raw(compiler) {
@@ -8889,9 +9261,9 @@ function toRawSplitChunksOptions(sc, compiler) {
 }
 
 // src/builtin-plugin/LightningCssMinimizerRspackPlugin.ts
-var import_binding63 = require("@rspack/binding");
+var import_binding64 = require("@rspack/binding");
 var LightningCssMinimizerRspackPlugin = create2(
-  import_binding63.BuiltinPluginName.LightningCssMinimizerRspackPlugin,
+  import_binding64.BuiltinPluginName.LightningCssMinimizerRspackPlugin,
   (options) => {
     var _a, _b, _c;
     const { include, exclude, draft, nonStandard, pseudoClasses, drafts } = (options == null ? void 0 : options.minimizerOptions) ?? {};
@@ -8919,16 +9291,16 @@ var LightningCssMinimizerRspackPlugin = create2(
 );
 
 // src/builtin-plugin/RemoveDuplicateModulesPlugin.ts
-var import_binding64 = require("@rspack/binding");
+var import_binding65 = require("@rspack/binding");
 var RemoveDuplicateModulesPlugin = create2(
-  import_binding64.BuiltinPluginName.RemoveDuplicateModulesPlugin,
+  import_binding65.BuiltinPluginName.RemoveDuplicateModulesPlugin,
   () => {
     return {};
   }
 );
 
 // src/builtin-plugin/SwcJsMinimizerPlugin.ts
-var import_binding65 = require("@rspack/binding");
+var import_binding66 = require("@rspack/binding");
 function isObject2(value) {
   const type = typeof value;
   return value != null && (type === "object" || type === "function");
@@ -8971,7 +9343,7 @@ function getRawExtractCommentsOptions(extractComments) {
   return void 0;
 }
 var SwcJsMinimizerRspackPlugin = create2(
-  import_binding65.BuiltinPluginName.SwcJsMinimizerRspackPlugin,
+  import_binding66.BuiltinPluginName.SwcJsMinimizerRspackPlugin,
   (options) => {
     var _a, _b, _c, _d, _e;
     let compress = ((_a = options == null ? void 0 : options.minimizerOptions) == null ? void 0 : _a.compress) ?? true;
@@ -9009,20 +9381,20 @@ var SwcJsMinimizerRspackPlugin = create2(
 );
 
 // src/builtin-plugin/WarnCaseSensitiveModulesPlugin.ts
-var import_binding66 = require("@rspack/binding");
+var import_binding67 = require("@rspack/binding");
 var WarnCaseSensitiveModulesPlugin = create2(
-  import_binding66.BuiltinPluginName.WarnCaseSensitiveModulesPlugin,
+  import_binding67.BuiltinPluginName.WarnCaseSensitiveModulesPlugin,
   () => {
   },
   "compilation"
 );
 
 // src/builtin-plugin/WebWorkerTemplatePlugin.ts
-var import_binding67 = require("@rspack/binding");
+var import_binding68 = require("@rspack/binding");
 var WebWorkerTemplatePlugin = class extends RspackBuiltinPlugin {
   constructor() {
     super(...arguments);
-    this.name = import_binding67.BuiltinPluginName.WebWorkerTemplatePlugin;
+    this.name = import_binding68.BuiltinPluginName.WebWorkerTemplatePlugin;
   }
   raw(compiler) {
     compiler.options.output.chunkLoading = "import-scripts";
@@ -9031,7 +9403,7 @@ var WebWorkerTemplatePlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/WorkerPlugin.ts
-var import_binding68 = require("@rspack/binding");
+var import_binding69 = require("@rspack/binding");
 var WorkerPlugin = class extends RspackBuiltinPlugin {
   constructor(chunkLoading2, wasmLoading2, module2, workerPublicPath2) {
     super();
@@ -9039,7 +9411,7 @@ var WorkerPlugin = class extends RspackBuiltinPlugin {
     this.wasmLoading = wasmLoading2;
     this.module = module2;
     this.workerPublicPath = workerPublicPath2;
-    this.name = import_binding68.BuiltinPluginName.WorkerPlugin;
+    this.name = import_binding69.BuiltinPluginName.WorkerPlugin;
   }
   raw(compiler) {
     if (this.chunkLoading) {
@@ -9053,25 +9425,25 @@ var WorkerPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/builtin-plugin/FetchCompileAsyncWasmPlugin.ts
-var import_binding69 = require("@rspack/binding");
+var import_binding70 = require("@rspack/binding");
 var FetchCompileAsyncWasmPlugin = create2(
-  import_binding69.BuiltinPluginName.FetchCompileAsyncWasmPlugin,
+  import_binding70.BuiltinPluginName.FetchCompileAsyncWasmPlugin,
   () => {
   },
   "thisCompilation"
 );
 
 // src/builtin-plugin/NoEmitOnErrorsPlugin.ts
-var import_binding70 = require("@rspack/binding");
+var import_binding71 = require("@rspack/binding");
 var NoEmitOnErrorsPlugin = create2(
-  import_binding70.BuiltinPluginName.NoEmitOnErrorsPlugin,
+  import_binding71.BuiltinPluginName.NoEmitOnErrorsPlugin,
   () => void 0
 );
 
 // src/builtin-plugin/ContextReplacementPlugin.ts
-var import_binding71 = require("@rspack/binding");
+var import_binding72 = require("@rspack/binding");
 var ContextReplacementPlugin = create2(
-  import_binding71.BuiltinPluginName.ContextReplacementPlugin,
+  import_binding72.BuiltinPluginName.ContextReplacementPlugin,
   (resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) => {
     const rawOptions = {
       resourceRegExp
@@ -9101,26 +9473,26 @@ var ContextReplacementPlugin = create2(
 );
 
 // src/builtin-plugin/LibManifestPlugin.ts
-var import_binding72 = require("@rspack/binding");
+var import_binding73 = require("@rspack/binding");
 var LibManifestPlugin = create2(
-  import_binding72.BuiltinPluginName.LibManifestPlugin,
+  import_binding73.BuiltinPluginName.LibManifestPlugin,
   (options) => {
-    const { context: context2, entryOnly, format: format3, name: name2, path: path11, type } = options;
+    const { context: context2, entryOnly, format: format3, name: name2, path: path13, type } = options;
     return {
       context: context2,
       entryOnly,
       format: format3,
       name: name2,
-      path: path11,
+      path: path13,
       type
     };
   }
 );
 
 // src/builtin-plugin/DllEntryPlugin.ts
-var import_binding73 = require("@rspack/binding");
+var import_binding74 = require("@rspack/binding");
 var DllEntryPlugin = create2(
-  import_binding73.BuiltinPluginName.DllEntryPlugin,
+  import_binding74.BuiltinPluginName.DllEntryPlugin,
   (context2, entries, options) => {
     return {
       context: context2,
@@ -9131,14 +9503,14 @@ var DllEntryPlugin = create2(
 );
 
 // src/builtin-plugin/DllReferenceAgencyPlugin.ts
-var import_binding74 = require("@rspack/binding");
+var import_binding75 = require("@rspack/binding");
 var DllReferenceAgencyPlugin = create2(
-  import_binding74.BuiltinPluginName.DllReferenceAgencyPlugin,
+  import_binding75.BuiltinPluginName.DllReferenceAgencyPlugin,
   (options) => options
 );
 
 // src/builtin-plugin/RsdoctorPlugin.ts
-var import_binding75 = require("@rspack/binding");
+var import_binding76 = require("@rspack/binding");
 var liteTapable8 = __toESM(require("@rspack/lite-tapable"));
 var import_zod3 = require("../compiled/zod/index.js");
 var rsdoctorPluginSchema = import_zod3.z.strictObject({
@@ -9146,7 +9518,7 @@ var rsdoctorPluginSchema = import_zod3.z.strictObject({
   chunkGraphFeatures: import_zod3.z.union([import_zod3.z.boolean(), import_zod3.z.array(import_zod3.z.enum(["graph", "assets"]))]).optional()
 });
 var RsdoctorPluginImpl = create2(
-  import_binding75.BuiltinPluginName.RsdoctorPlugin,
+  import_binding76.BuiltinPluginName.RsdoctorPlugin,
   function(c = {
     moduleGraphFeatures: true,
     chunkGraphFeatures: true
@@ -9161,11 +9533,7 @@ var RsdoctorPluginImpl = create2(
 var compilationHooksMap5 = /* @__PURE__ */ new WeakMap();
 var RsdoctorPlugin = RsdoctorPluginImpl;
 RsdoctorPlugin.getHooks = RsdoctorPlugin.getCompilationHooks = (compilation) => {
-  if (!(compilation instanceof Compilation)) {
-    throw new TypeError(
-      "The 'compilation' argument must be an instance of Compilation"
-    );
-  }
+  checkCompilation(compilation);
   let hooks = compilationHooksMap5.get(compilation);
   if (hooks === void 0) {
     hooks = {
@@ -9182,7 +9550,7 @@ RsdoctorPlugin.getHooks = RsdoctorPlugin.getCompilationHooks = (compilation) =>
 var createRsdoctorPluginHooksRegisters = (getCompiler, createTap, createMapTap) => {
   return {
     registerRsdoctorPluginModuleGraphTaps: createTap(
-      import_binding75.RegisterJsTapKind.RsdoctorPluginModuleGraph,
+      import_binding76.RegisterJsTapKind.RsdoctorPluginModuleGraph,
       function() {
         return RsdoctorPlugin.getCompilationHooks(
           getCompiler().__internal__get_compilation()
@@ -9195,7 +9563,7 @@ var createRsdoctorPluginHooksRegisters = (getCompiler, createTap, createMapTap)
       }
     ),
     registerRsdoctorPluginChunkGraphTaps: createTap(
-      import_binding75.RegisterJsTapKind.RsdoctorPluginChunkGraph,
+      import_binding76.RegisterJsTapKind.RsdoctorPluginChunkGraph,
       function() {
         return RsdoctorPlugin.getCompilationHooks(
           getCompiler().__internal__get_compilation()
@@ -9208,7 +9576,7 @@ var createRsdoctorPluginHooksRegisters = (getCompiler, createTap, createMapTap)
       }
     ),
     registerRsdoctorPluginModuleIdsTaps: createTap(
-      import_binding75.RegisterJsTapKind.RsdoctorPluginModuleIds,
+      import_binding76.RegisterJsTapKind.RsdoctorPluginModuleIds,
       function() {
         return RsdoctorPlugin.getCompilationHooks(
           getCompiler().__internal__get_compilation()
@@ -9221,7 +9589,7 @@ var createRsdoctorPluginHooksRegisters = (getCompiler, createTap, createMapTap)
       }
     ),
     registerRsdoctorPluginModuleSourcesTaps: createTap(
-      import_binding75.RegisterJsTapKind.RsdoctorPluginModuleSources,
+      import_binding76.RegisterJsTapKind.RsdoctorPluginModuleSources,
       function() {
         return RsdoctorPlugin.getCompilationHooks(
           getCompiler().__internal__get_compilation()
@@ -9234,7 +9602,7 @@ var createRsdoctorPluginHooksRegisters = (getCompiler, createTap, createMapTap)
       }
     ),
     registerRsdoctorPluginAssetsTaps: createTap(
-      import_binding75.RegisterJsTapKind.RsdoctorPluginAssets,
+      import_binding76.RegisterJsTapKind.RsdoctorPluginAssets,
       function() {
         return RsdoctorPlugin.getCompilationHooks(
           getCompiler().__internal__get_compilation()
@@ -9252,8 +9620,8 @@ 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_binding76 = require("@rspack/binding");
+var import_node_path9 = require("path");
+var import_binding77 = require("@rspack/binding");
 var import_zod4 = require("../compiled/zod/index.js");
 var PLUGIN_NAME2 = "SubresourceIntegrityPlugin";
 var NATIVE_HTML_PLUGIN = "HtmlRspackPlugin";
@@ -9264,7 +9632,7 @@ var pluginOptionsSchema2 = import_zod4.z.object({
   enabled: import_zod4.z.literal("auto").or(import_zod4.z.boolean()).optional()
 });
 var NativeSubresourceIntegrityPlugin = create2(
-  import_binding76.BuiltinPluginName.SubresourceIntegrityPlugin,
+  import_binding77.BuiltinPluginName.SubresourceIntegrityPlugin,
   function(options) {
     let htmlPlugin = "Disabled";
     if (options.htmlPlugin === NATIVE_HTML_PLUGIN) {
@@ -9334,7 +9702,7 @@ var SubresourceIntegrityPlugin = class extends NativeSubresourceIntegrityPlugin
     for (const asset of assets.js) {
       jsIntegrity.push(
         this.getIntegrityChecksumForAsset(
-          (0, import_node_path7.relative)(publicPath2, decodeURIComponent(asset))
+          (0, import_node_path9.relative)(publicPath2, decodeURIComponent(asset))
         )
       );
     }
@@ -9342,7 +9710,7 @@ var SubresourceIntegrityPlugin = class extends NativeSubresourceIntegrityPlugin
     for (const asset of assets.css) {
       cssIntegrity.push(
         this.getIntegrityChecksumForAsset(
-          (0, import_node_path7.relative)(publicPath2, decodeURIComponent(asset))
+          (0, import_node_path9.relative)(publicPath2, decodeURIComponent(asset))
         )
       );
     }
@@ -9362,10 +9730,10 @@ var SubresourceIntegrityPlugin = class extends NativeSubresourceIntegrityPlugin
     if (!tagSrc) {
       return;
     }
-    const src = (0, import_node_path7.relative)(publicPath2, decodeURIComponent(tagSrc));
+    const src = (0, import_node_path9.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))
+      (0, import_node_fs2.readFileSync)((0, import_node_path9.join)(outputPath, src))
     );
     tag.attributes.crossorigin = crossOriginLoading2 || "anonymous";
   }
@@ -9465,14 +9833,14 @@ function computeIntegrity(hashFuncNames, source) {
   ).join(" ");
   return result2;
 }
-function normalizePath(path11) {
-  return path11.replace(/\?.*$/, "").split(import_node_path7.sep).join("/");
+function normalizePath(path13) {
+  return path13.replace(/\?.*$/, "").split(import_node_path9.sep).join("/");
 }
 
 // src/builtin-plugin/ModuleInfoHeaderPlugin.ts
-var import_binding77 = require("@rspack/binding");
+var import_binding78 = require("@rspack/binding");
 var ModuleInfoHeaderPlugin = create2(
-  import_binding77.BuiltinPluginName.ModuleInfoHeaderPlugin,
+  import_binding78.BuiltinPluginName.ModuleInfoHeaderPlugin,
   (verbose) => verbose,
   "compilation"
 );
@@ -9811,13 +10179,13 @@ __export(browserslistTargetHandler_exports, {
   load: () => load,
   resolve: () => resolve
 });
-var import_node_path8 = __toESM(require("path"));
+var import_node_path10 = __toESM(require("path"));
 var inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
 var parse = (input, context2) => {
   if (!input) {
     return {};
   }
-  if (import_node_path8.default.isAbsolute(input)) {
+  if (import_node_path10.default.isAbsolute(input)) {
     const [, configPath, env] = inputRx.exec(input) || [];
     return { configPath, env };
   }
@@ -10416,7 +10784,8 @@ var applyRspackOptionsDefaults = (options) => {
     options.output.library
   );
   applyExternalsPresetsDefaults(options.externalsPresets, {
-    targetProperties
+    targetProperties,
+    buildHttp: Boolean(options.experiments.buildHttp)
   });
   F(options, "externalsType", () => {
     return options.output.library ? (
@@ -10479,6 +10848,10 @@ var applyExperimentsDefaults = (experiments3, { production, development }) => {
   D(experiments3, "css", experiments3.futureDefaults ? true : void 0);
   D(experiments3, "layers", false);
   D(experiments3, "topLevelAwait", true);
+  D(experiments3, "buildHttp", void 0);
+  if (experiments3.buildHttp && typeof experiments3.buildHttp === "object") {
+    D(experiments3.buildHttp, "upgrade", false);
+  }
   D(experiments3, "incremental", !production ? {} : false);
   if (typeof experiments3.incremental === "object") {
     D(experiments3.incremental, "make", true);
@@ -10498,7 +10871,8 @@ var applyExperimentsDefaults = (experiments3, { production, development }) => {
     D(experiments3.incremental, "emitAssets", true);
   }
   D(experiments3, "rspackFuture", {});
-  D(experiments3, "parallelCodeSplitting", false);
+  D(experiments3, "parallelCodeSplitting", true);
+  D(experiments3, "parallelLoader", false);
 };
 var applybundlerInfoDefaults = (rspackFuture, library3) => {
   if (typeof rspackFuture === "object") {
@@ -10761,7 +11135,7 @@ var applyOutputDefaults = (output2, {
       }
     );
     if (libraryName2) return libraryName2;
-    const pkgPath = import_node_path9.default.resolve(context2, "package.json");
+    const pkgPath = import_node_path11.default.resolve(context2, "package.json");
     try {
       const packageInfo = JSON.parse(import_node_fs3.default.readFileSync(pkgPath, "utf-8"));
       return packageInfo.name || "";
@@ -10817,7 +11191,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_path9.default.join(process.cwd(), "dist"));
+  F(output2, "path", () => import_node_path11.default.join(process.cwd(), "dist"));
   F(output2, "pathinfo", () => development);
   D(
     output2,
@@ -11020,8 +11394,8 @@ ${helpMessage}`
   );
   F(environment2, "document", () => tp && optimistic(tp.document));
 };
-var applyExternalsPresetsDefaults = (externalsPresets2, { targetProperties }) => {
-  D(externalsPresets2, "web", targetProperties == null ? void 0 : targetProperties.web);
+var applyExternalsPresetsDefaults = (externalsPresets2, { targetProperties, buildHttp }) => {
+  D(externalsPresets2, "web", !buildHttp && (targetProperties == null ? void 0 : targetProperties.web));
   D(externalsPresets2, "node", targetProperties == null ? void 0 : targetProperties.node);
   D(externalsPresets2, "electron", targetProperties == null ? void 0 : targetProperties.electron);
   D(
@@ -11088,7 +11462,7 @@ var applyOptimizationDefaults = (optimization2, {
   development,
   css
 }) => {
-  D(optimization2, "removeAvailableModules", false);
+  D(optimization2, "removeAvailableModules", true);
   D(optimization2, "removeEmptyChunks", true);
   D(optimization2, "mergeDuplicateChunks", true);
   F(optimization2, "moduleIds", () => {
@@ -11292,7 +11666,7 @@ var getPnpDefault = () => {
 };
 
 // src/config/normalization.ts
-var import_node_path10 = __toESM(require("path"));
+var import_node_path12 = __toESM(require("path"));
 var import_node_util5 = __toESM(require("util"));
 var getNormalizedRspackOptions = (config2) => {
   return {
@@ -11482,7 +11856,7 @@ var getNormalizedRspackOptions = (config2) => {
           type: "persistent",
           buildDependencies: nestedArray(
             cache.buildDependencies,
-            (deps) => deps.map((d) => import_node_path10.default.resolve(config2.context || process.cwd(), d))
+            (deps) => deps.map((d) => import_node_path12.default.resolve(config2.context || process.cwd(), d))
           ),
           version: cache.version || "",
           snapshot: {
@@ -11494,7 +11868,7 @@ var getNormalizedRspackOptions = (config2) => {
           },
           storage: {
             type: "filesystem",
-            directory: import_node_path10.default.resolve(
+            directory: import_node_path12.default.resolve(
               config2.context || process.cwd(),
               ((_a = cache.storage) == null ? void 0 : _a.directory) || "node_modules/.cache/rspack"
             )
@@ -11525,7 +11899,9 @@ var getNormalizedRspackOptions = (config2) => {
           emitAssets: true
         } : options
       ),
-      parallelCodeSplitting: experiments3.parallelCodeSplitting
+      parallelCodeSplitting: experiments3.parallelCodeSplitting,
+      buildHttp: experiments3.buildHttp,
+      parallelLoader: experiments3.parallelLoader
     })),
     watch: config2.watch,
     watchOptions: cloneObject(config2.watchOptions),
@@ -11631,14 +12007,14 @@ var Resolver = class _Resolver {
   constructor(binding14) {
     this.binding = binding14;
   }
-  resolveSync(context2, path11, request) {
-    const data = this.binding.resolveSync(path11, request);
+  resolveSync(context2, path13, request) {
+    const data = this.binding.resolveSync(path13, request);
     if (data === false) return data;
     return data.resource;
   }
-  resolve(context2, path11, request, resolveContext, callback) {
+  resolve(context2, path13, request, resolveContext, callback) {
     try {
-      const data = this.binding.resolveSync(path11, request);
+      const data = this.binding.resolveSync(path13, request);
       if (data === false) {
         callback(null, false);
         return;
@@ -11820,8 +12196,19 @@ var Watching = class {
     this.onChange();
     this.#invalidate();
   }
-  invalidateWithChangedFiles(files) {
-    this.#invalidate(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), files, /* @__PURE__ */ new Set());
+  /**
+   * @internal This is not a public API yet, still unstable, might change in the future
+   */
+  invalidateWithChangesAndRemovals(changedFiles, removedFiles, callback) {
+    if (callback) {
+      this.callbacks.push(callback);
+    }
+    if (!this.#invalidReported) {
+      this.#invalidReported = true;
+      this.compiler.hooks.invalid.call(null, Date.now());
+    }
+    this.onChange();
+    this.#invalidate(void 0, void 0, changedFiles, removedFiles);
   }
   #invalidate(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
     this.#mergeWithCollected(changedFiles, removedFiles);
@@ -11942,16 +12329,18 @@ var Watching = class {
     });
   }
   #mergeWithCollected(changedFiles, removedFiles) {
-    if (!changedFiles) return;
-    if (!removedFiles) return;
     if (!this.#collectedChangedFiles || !this.#collectedRemovedFiles) {
       this.#collectedChangedFiles = new Set(changedFiles);
       this.#collectedRemovedFiles = new Set(removedFiles);
-    } else {
+      return;
+    }
+    if (changedFiles) {
       for (const file of changedFiles) {
         this.#collectedChangedFiles.add(file);
         this.#collectedRemovedFiles.delete(file);
       }
+    }
+    if (removedFiles) {
       for (const file of removedFiles) {
         this.#collectedChangedFiles.delete(file);
         this.#collectedRemovedFiles.add(file);
@@ -11971,7 +12360,7 @@ var Watching = class {
 
 // src/util/bindingVersionCheck.ts
 var import_node_fs4 = require("fs");
-var import_node_path11 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var NodePlatformArchToAbi = {
   android: {
     arm64: "",
@@ -12043,7 +12432,7 @@ var checkVersion = () => {
   }
   let ADDON_VERSION;
   try {
-    const BINDING_PKG_DIR = import_node_path11.default.dirname(
+    const BINDING_PKG_DIR = import_node_path13.default.dirname(
       require.resolve("@rspack/binding/package.json")
     );
     const isLocal = (0, import_node_fs4.readdirSync)(BINDING_PKG_DIR).some(
@@ -12219,7 +12608,7 @@ var binding6 = __toESM(require("@rspack/binding"));
 
 // src/Module.ts
 var binding5 = __toESM(require("@rspack/binding"));
-var import_binding78 = require("@rspack/binding");
+var import_binding79 = require("@rspack/binding");
 var ContextModuleFactoryBeforeResolveData = class _ContextModuleFactoryBeforeResolveData {
   #inner;
   static __from_binding(binding14) {
@@ -13611,7 +14000,7 @@ var Compiler = class _Compiler {
         return finalCallback(null, stats);
       });
     };
-    const run = () => {
+    const run2 = () => {
       this.hooks.beforeRun.callAsync(this, (err) => {
         if (err) {
           return finalCallback(err);
@@ -13628,10 +14017,10 @@ var Compiler = class _Compiler {
       this.cache.endIdle((err) => {
         if (err) return callback(err);
         this.idle = false;
-        run();
+        run2();
       });
     } else {
-      run();
+      run2();
     }
   }
   runAsChild(callback) {
@@ -14483,7 +14872,7 @@ var MultiCompiler = class {
    * @param {Callback<MultiStats>} callback callback when all compilers are done, result includes Stats of all changed compilers
    * @returns {SetupResult[]} result of setup
    */
-  #runGraph(setup, run, callback) {
+  #runGraph(setup, run2, callback) {
     const nodes = this.compilers.map((compiler) => ({
       compiler,
       setupResult: void 0,
@@ -14597,7 +14986,7 @@ var MultiCompiler = class {
         if (node3.state === "queued" || node3.state === "blocked" && node3.parents.every((p) => p.state === "done")) {
           running++;
           node3.state = "starting";
-          run(
+          run2(
             node3.compiler,
             node3.setupResult,
             nodeDone.bind(null, node3)
@@ -15116,17 +15505,17 @@ var ASSETS_GROUPERS = {
           const extensionMatch = groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
           const extension = extensionMatch ? extensionMatch[1] : "";
           const pathMatch = groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
-          const path11 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+          const path13 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
           const keys = [];
           if (groupAssetsByPath) {
             keys.push(".");
             if (extension)
               keys.push(
-                path11.length ? `${path11.join("/")}/*${extension}` : `*${extension}`
+                path13.length ? `${path13.join("/")}/*${extension}` : `*${extension}`
               );
-            while (path11.length > 0) {
-              keys.push(`${path11.join("/")}/`);
-              path11.pop();
+            while (path13.length > 0) {
+              keys.push(`${path13.join("/")}/`);
+              path13.pop();
             }
           } else {
             if (extension) keys.push(`*${extension}`);
@@ -15312,16 +15701,16 @@ var MODULES_GROUPERS = (type) => ({
           const extensionMatch = groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
           const extension = extensionMatch ? extensionMatch[1] : "";
           const pathMatch = groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
-          const path11 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+          const path13 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
           const keys = [];
           if (groupModulesByPath) {
             if (extension)
               keys.push(
-                path11.length ? `${path11.join("/")}/*${extension}` : `*${extension}`
+                path13.length ? `${path13.join("/")}/*${extension}` : `*${extension}`
               );
-            while (path11.length > 0) {
-              keys.push(`${path11.join("/")}/`);
-              path11.pop();
+            while (path13.length > 0) {
+              keys.push(`${path13.join("/")}/`);
+              path13.pop();
             }
           } else {
             if (extension) keys.push(`*${extension}`);
@@ -17762,6 +18151,9 @@ var RspackOptionsApply = class {
     new APIPlugin().apply(compiler);
     new DataUriPlugin().apply(compiler);
     new FileUriPlugin().apply(compiler);
+    if (options.experiments.buildHttp) {
+      new HttpUriPlugin(options.experiments.buildHttp).apply(compiler);
+    }
     new EnsureChunkConditionsPlugin().apply(compiler);
     if (options.optimization.mergeDuplicateChunks) {
       new MergeDuplicateChunksPlugin().apply(compiler);
@@ -17896,7 +18288,7 @@ var RspackOptionsApply = class {
 
 // src/ContextModule.ts
 var binding11 = __toESM(require("@rspack/binding"));
-var import_binding79 = require("@rspack/binding");
+var import_binding80 = require("@rspack/binding");
 Object.defineProperty(binding11.ContextModule.prototype, "originalSource", {
   enumerable: true,
   configurable: true,
@@ -17918,7 +18310,7 @@ Object.defineProperty(binding11.ContextModule.prototype, "emitFile", {
 
 // src/ConcatenatedModule.ts
 var binding12 = __toESM(require("@rspack/binding"));
-var import_binding80 = require("@rspack/binding");
+var import_binding81 = require("@rspack/binding");
 Object.defineProperty(binding12.ConcatenatedModule.prototype, "originalSource", {
   enumerable: true,
   configurable: true,
@@ -17940,7 +18332,7 @@ Object.defineProperty(binding12.ConcatenatedModule.prototype, "emitFile", {
 
 // src/ExternalModule.ts
 var binding13 = __toESM(require("@rspack/binding"));
-var import_binding81 = require("@rspack/binding");
+var import_binding82 = require("@rspack/binding");
 Object.defineProperty(binding13.ExternalModule.prototype, "originalSource", {
   enumerable: true,
   configurable: true,
@@ -17961,7 +18353,7 @@ Object.defineProperty(binding13.ExternalModule.prototype, "emitFile", {
 });
 
 // src/exports.ts
-var import_binding89 = require("@rspack/binding");
+var import_binding90 = require("@rspack/binding");
 
 // src/lib/ModuleFilenameHelpers.ts
 var ModuleFilenameHelpers_exports = {};
@@ -18006,9 +18398,9 @@ var matchObject = (obj, str) => {
 var import_zod5 = __toESM(require("../compiled/zod/index.js"));
 
 // src/builtin-plugin/FlagAllModulesAsUsedPlugin.ts
-var import_binding82 = require("@rspack/binding");
+var import_binding83 = require("@rspack/binding");
 var FlagAllModulesAsUsedPlugin = create2(
-  import_binding82.BuiltinPluginName.FlagAllModulesAsUsedPlugin,
+  import_binding83.BuiltinPluginName.FlagAllModulesAsUsedPlugin,
   (explanation) => {
     return {
       explanation
@@ -18897,7 +19289,7 @@ var NodeTemplatePlugin = class {
 };
 
 // src/config/zod.ts
-var import_node_path12 = __toESM(require("path"));
+var import_node_path14 = __toESM(require("path"));
 var import_zod8 = require("../compiled/zod/index.js");
 
 // src/config/utils.ts
@@ -19055,7 +19447,7 @@ var filename = filenameTemplate.or(
 var name = import_zod8.z.string();
 var dependencies = import_zod8.z.array(name);
 var context = import_zod8.z.string().refine(
-  (val) => import_node_path12.default.isAbsolute(val),
+  (val) => import_node_path14.default.isAbsolute(val),
   (val) => ({
     message: `The provided value ${JSON.stringify(val)} must be an absolute path.`
   })
@@ -19154,7 +19546,7 @@ var entryDynamic = import_zod8.z.function().returns(
   entryStatic.or(import_zod8.z.promise(entryStatic))
 );
 var entry = entryStatic.or(entryDynamic);
-var path10 = import_zod8.z.string();
+var path12 = import_zod8.z.string();
 var pathinfo = import_zod8.z.boolean().or(import_zod8.z.literal("verbose"));
 var assetModuleFilename = filename;
 var webassemblyModuleFilename = import_zod8.z.string();
@@ -19228,7 +19620,7 @@ var environment = import_zod8.z.strictObject({
   templateLiteral: import_zod8.z.boolean().optional()
 });
 var output = import_zod8.z.strictObject({
-  path: path10.optional(),
+  path: path12.optional(),
   pathinfo: pathinfo.optional(),
   clean: clean.optional(),
   publicPath: publicPath.optional(),
@@ -19284,7 +19676,7 @@ var output = import_zod8.z.strictObject({
 });
 var resolveAlias = import_zod8.z.record(
   import_zod8.z.literal(false).or(import_zod8.z.string()).or(import_zod8.z.array(import_zod8.z.string().or(import_zod8.z.literal(false))))
-);
+).or(import_zod8.z.literal(false));
 var resolveTsConfigFile = import_zod8.z.string();
 var resolveTsConfig = resolveTsConfigFile.or(
   import_zod8.z.strictObject({
@@ -19333,7 +19725,8 @@ var ruleSetLoaderOptions = import_zod8.z.string().or(import_zod8.z.record(import
 var ruleSetLoaderWithOptions = import_zod8.z.strictObject({
   ident: import_zod8.z.string().optional(),
   loader: ruleSetLoader,
-  options: ruleSetLoaderOptions.optional()
+  options: ruleSetLoaderOptions.optional(),
+  parallel: import_zod8.z.boolean().optional()
 });
 var ruleSetUseItem = ruleSetLoader.or(
   ruleSetLoaderWithOptions
@@ -19865,7 +20258,7 @@ var optimizationRuntimeChunk = import_zod8.z.enum(["single", "multiple"]).or(imp
     ).optional()
   })
 );
-var optimizationSplitChunksNameFunction = import_zod8.z.function().args(import_zod8.z.instanceof(import_binding78.Module), import_zod8.z.array(import_zod8.z.instanceof(Chunk)), import_zod8.z.string()).returns(
+var optimizationSplitChunksNameFunction = import_zod8.z.function().args(import_zod8.z.instanceof(import_binding79.Module), import_zod8.z.array(import_zod8.z.instanceof(Chunk)), import_zod8.z.string()).returns(
   import_zod8.z.string().optional()
 );
 var optimizationSplitChunksName = import_zod8.z.string().or(import_zod8.z.literal(false)).or(optimizationSplitChunksNameFunction);
@@ -19892,7 +20285,7 @@ var sharedOptimizationSplitChunksCacheGroup = {
 var optimizationSplitChunksCacheGroup = import_zod8.z.strictObject({
   test: import_zod8.z.string().or(import_zod8.z.instanceof(RegExp)).or(
     import_zod8.z.function().args(
-      import_zod8.z.instanceof(import_binding78.Module),
+      import_zod8.z.instanceof(import_binding79.Module),
       import_zod8.z.object({
         moduleGraph: import_zod8.z.instanceof(ModuleGraph),
         chunkGraph: import_zod8.z.instanceof(ChunkGraph)
@@ -19990,6 +20383,23 @@ var incremental = import_zod8.z.strictObject({
   chunksRender: import_zod8.z.boolean().optional(),
   emitAssets: import_zod8.z.boolean().optional()
 });
+var buildHttpOptions = import_zod8.z.object({
+  allowedUris: import_zod8.z.array(import_zod8.z.union([import_zod8.z.string(), import_zod8.z.instanceof(RegExp)])),
+  lockfileLocation: import_zod8.z.string().optional(),
+  cacheLocation: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.literal(false)]).optional(),
+  upgrade: import_zod8.z.boolean().optional(),
+  // proxy: z.string().optional(),
+  // frozen: z.boolean().optional(),
+  httpClient: import_zod8.z.function().args(import_zod8.z.string(), import_zod8.z.record(import_zod8.z.string())).returns(
+    import_zod8.z.promise(
+      import_zod8.z.object({
+        status: import_zod8.z.number(),
+        headers: import_zod8.z.record(import_zod8.z.string()),
+        body: import_zod8.z.instanceof(Buffer)
+      })
+    )
+  ).optional()
+});
 var experiments = import_zod8.z.strictObject({
   cache: import_zod8.z.boolean().optional().or(experimentCacheOptions),
   lazyCompilation: import_zod8.z.boolean().optional().or(lazyCompilationOptions),
@@ -20001,7 +20411,9 @@ var experiments = import_zod8.z.strictObject({
   incremental: import_zod8.z.boolean().or(incremental).optional(),
   parallelCodeSplitting: import_zod8.z.boolean().optional(),
   futureDefaults: import_zod8.z.boolean().optional(),
-  rspackFuture: rspackFutureOptions.optional()
+  rspackFuture: rspackFutureOptions.optional(),
+  buildHttp: buildHttpOptions.optional(),
+  parallelLoader: import_zod8.z.boolean().optional()
 });
 var watch = import_zod8.z.boolean();
 var watchOptions = import_zod8.z.strictObject({
@@ -20060,9 +20472,9 @@ var rspackOptions = import_zod8.z.strictObject({
 });
 
 // src/container/ModuleFederationRuntimePlugin.ts
-var import_binding83 = require("@rspack/binding");
+var import_binding84 = require("@rspack/binding");
 var ModuleFederationRuntimePlugin = create2(
-  import_binding83.BuiltinPluginName.ModuleFederationRuntimePlugin,
+  import_binding84.BuiltinPluginName.ModuleFederationRuntimePlugin,
   () => {
   }
 );
@@ -20258,10 +20670,10 @@ function getDefaultEntryRuntime(paths, options, compiler) {
 }
 
 // src/sharing/ConsumeSharedPlugin.ts
-var import_binding85 = require("@rspack/binding");
+var import_binding86 = require("@rspack/binding");
 
 // src/sharing/ShareRuntimePlugin.ts
-var import_binding84 = require("@rspack/binding");
+var import_binding85 = require("@rspack/binding");
 var compilerSet = /* @__PURE__ */ new WeakSet();
 function isSingleton(compiler) {
   return compilerSet.has(compiler);
@@ -20273,7 +20685,7 @@ var ShareRuntimePlugin = class extends RspackBuiltinPlugin {
   constructor(enhanced = false) {
     super();
     this.enhanced = enhanced;
-    this.name = import_binding84.BuiltinPluginName.ShareRuntimePlugin;
+    this.name = import_binding85.BuiltinPluginName.ShareRuntimePlugin;
   }
   raw(compiler) {
     if (isSingleton(compiler)) return;
@@ -20292,7 +20704,7 @@ function isRequiredVersion(str) {
 var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding85.BuiltinPluginName.ConsumeSharedPlugin;
+    this.name = import_binding86.BuiltinPluginName.ConsumeSharedPlugin;
     this._options = {
       consumes: parseOptions(
         options.consumes,
@@ -20355,11 +20767,11 @@ var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/sharing/ProvideSharedPlugin.ts
-var import_binding86 = require("@rspack/binding");
+var import_binding87 = require("@rspack/binding");
 var ProvideSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding86.BuiltinPluginName.ProvideSharedPlugin;
+    this.name = import_binding87.BuiltinPluginName.ProvideSharedPlugin;
     this._provides = parseOptions(
       options.provides,
       (item) => {
@@ -20464,11 +20876,11 @@ var SharePlugin = class {
 };
 
 // src/container/ContainerPlugin.ts
-var import_binding87 = require("@rspack/binding");
+var import_binding88 = require("@rspack/binding");
 var ContainerPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding87.BuiltinPluginName.ContainerPlugin;
+    this.name = import_binding88.BuiltinPluginName.ContainerPlugin;
     this._options = {
       name: options.name,
       shareScope: options.shareScope || "default",
@@ -20512,11 +20924,11 @@ var ContainerPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/container/ContainerReferencePlugin.ts
-var import_binding88 = require("@rspack/binding");
+var import_binding89 = require("@rspack/binding");
 var ContainerReferencePlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding88.BuiltinPluginName.ContainerReferencePlugin;
+    this.name = import_binding89.BuiltinPluginName.ContainerReferencePlugin;
     this._options = {
       remoteType: options.remoteType,
       remotes: parseOptions(
@@ -20601,7 +21013,7 @@ var ModuleFederationPluginV1 = class {
 };
 
 // src/exports.ts
-var import_binding90 = require("@rspack/binding");
+var import_binding91 = require("@rspack/binding");
 var rspackVersion = import_package.version;
 var version = import_package.webpackVersion;
 var WebpackError2 = Error;
@@ -20648,7 +21060,7 @@ var sharing = {
 var experiments2 = {
   globalTrace: {
     async register(filter, layer2, output2) {
-      (0, import_binding90.registerGlobalTrace)(filter, layer2, output2);
+      (0, import_binding91.registerGlobalTrace)(filter, layer2, output2);
       if (layer2 === "otel") {
         try {
           const { initOpenTelemetry } = await import("@rspack/tracing");
@@ -20662,7 +21074,7 @@ var experiments2 = {
       }
     },
     async cleanup() {
-      (0, import_binding90.cleanupGlobalTrace)();
+      (0, import_binding91.cleanupGlobalTrace)();
       try {
         const { shutdownOpenTelemetry } = await import("@rspack/tracing");
         await shutdownOpenTelemetry();