@rspack/core 1.3.0 → 1.3.2

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 = (path12) => {
-      let idx = path12.length - 1;
+    var dirname4 = (path13) => {
+      let idx = path13.length - 1;
       while (idx >= 0) {
-        const c = path12.charCodeAt(idx);
+        const c = path13.charCodeAt(idx);
         if (c === 47 || c === 92) break;
         idx--;
       }
       if (idx < 0) return "";
-      return path12.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
            */
-          (path12, options, callback) => {
+          (path13, options, callback) => {
             if (typeof options === "function") {
               callback = /** @type {FileSystemCallback<any>} */
               options;
               options = void 0;
             }
-            if (typeof path12 !== "string" && !Buffer.isBuffer(path12) && !(path12 instanceof URL) && typeof path12 !== "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,
-                  path12,
+                  path13,
                   options,
                   callback
                 )
               );
             }
-            let callbacks = this._activeAsyncOperations.get(path12);
+            let callbacks = this._activeAsyncOperations.get(path13);
             if (callbacks) {
               callbacks.push(callback);
               return;
             }
-            this._activeAsyncOperations.set(path12, callbacks = [callback]);
+            this._activeAsyncOperations.set(path13, callbacks = [callback]);
             provider(
-              path12,
+              path13,
               /**
                * @param {Error} err error
                * @param {any} result result
                */
               (err, result2) => {
-                this._activeAsyncOperations.delete(path12);
+                this._activeAsyncOperations.delete(path13);
                 runCallbacks(callbacks, err, result2);
               }
             );
@@ -241,12 +241,12 @@ var require_CachedInputFileSystem = __commonJS({
            * @param {object=} options options
            * @returns {any} result
            */
-          (path12, options) => {
+          (path13, options) => {
             return (
               /** @type {Function} */
               this._syncProvider.call(
                 this._providerContext,
-                path12,
+                path13,
                 options
               )
             );
@@ -292,22 +292,22 @@ var require_CachedInputFileSystem = __commonJS({
        * @param {FileSystemCallback<any>} callback callback
        * @returns {void}
        */
-      provide(path12, options, callback) {
+      provide(path13, options, callback) {
         if (typeof options === "function") {
           callback = options;
           options = void 0;
         }
-        if (typeof path12 !== "string" && !Buffer.isBuffer(path12) && !(path12 instanceof URL) && typeof path12 !== "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 path12 !== "string" ? path12.toString() : path12;
+        const strPath = typeof path13 !== "string" ? path13.toString() : path13;
         if (options) {
           return (
             /** @type {Function} */
             this._provider.call(
               this._providerContext,
-              path12,
+              path13,
               options,
               callback
             )
@@ -329,7 +329,7 @@ var require_CachedInputFileSystem = __commonJS({
         this._activeAsyncOperations.set(strPath, callbacks = [callback]);
         this._provider.call(
           this._providerContext,
-          path12,
+          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(path12, options) {
-        if (typeof path12 !== "string" && !Buffer.isBuffer(path12) && !(path12 instanceof URL) && typeof path12 !== "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 path12 !== "string" ? path12.toString() : path12;
+        const strPath = typeof path13 !== "string" ? path13.toString() : path13;
         if (options) {
           return (
             /** @type {Function} */
             this._syncProvider.call(
               this._providerContext,
-              path12,
+              path13,
               options
             )
           );
@@ -382,7 +382,7 @@ var require_CachedInputFileSystem = __commonJS({
           result2 = /** @type {Function} */
           this._syncProvider.call(
             this._providerContext,
-            path12
+            path13
           );
         } catch (err) {
           this._storeResult(
@@ -471,11 +471,11 @@ var require_CachedInputFileSystem = __commonJS({
        * @param {Error | null} err error
        * @param {any} result result
        */
-      _storeResult(path12, err, result2) {
-        if (this._data.has(path12)) return;
+      _storeResult(path13, err, result2) {
+        if (this._data.has(path13)) return;
         const level = this._levels[this._currentLevel];
-        this._data.set(path12, { err, result: result2, level });
-        level.add(path12);
+        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
            */
-          ((path12, callback) => {
-            this.readFile(path12, (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
            */
-          ((path12) => {
-            const buffer = this.readFileSync(path12);
+          ((path13) => {
+            const buffer = this.readFileSync(path13);
             const data = JSON.parse(buffer.toString("utf-8"));
             return data;
           }),
@@ -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,166 @@ 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 isArray = Array.isArray(pendingRequestId);
+            const ids = isArray ? pendingRequestId : [pendingRequestId];
+            result2 = await Promise.all(
+              ids.map((id) => pendingRequests.get(id))
+            );
+            if (!isArray) {
+              result2 = result2[0];
+            }
+            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 +5468,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 +5605,10 @@ function createLoaderObject(loader2, compiler) {
   return obj;
 }
 var LoaderObject = class {
-  #loaderItem;
   constructor(loaderItem, compiler) {
     const {
       request,
-      path: path12,
+      path: path13,
       query,
       fragment,
       options,
@@ -5372,7 +5619,7 @@ var LoaderObject = class {
       type
     } = createLoaderObject(loaderItem, compiler);
     this.request = request;
-    this.path = path12;
+    this.path = path13;
     this.query = query;
     this.fragment = fragment;
     this.options = options;
@@ -5381,41 +5628,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 +5653,7 @@ var LoaderObject = class {
     return new this(loaderItem, compiler);
   }
   static __to_binding(loader2) {
-    return loader2.#loaderItem;
+    return loader2.loaderItem;
   }
 };
 var JsSourceMap = class {
@@ -5435,81 +5664,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(path12) {
-  if (path12 === "/") return "/";
-  const i = path12.lastIndexOf("/");
-  const j = path12.lastIndexOf("\\");
-  const i2 = path12.indexOf("/");
-  const j2 = path12.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 path12;
-  if (idx === idx2) return path12.slice(0, idx + 1);
-  return path12.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 +5724,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 +6074,271 @@ 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 normalModule = loaderContext._module instanceof import_binding2.NormalModule ? loaderContext._module : void 0;
+    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: {
+        options: {
+          output: {
+            // css-loader
+            environment: compiler._lastCompilation.outputOptions.environment
+          }
+        },
+        // css-loader
+        outputOptions: {
+          hashSalt: compiler._lastCompilation.outputOptions.hashSalt,
+          hashFunction: compiler._lastCompilation.outputOptions.hashFunction,
+          hashDigest: compiler._lastCompilation.outputOptions.hashDigest,
+          hashDigestLength: compiler._lastCompilation.outputOptions.hashDigestLength
+        }
+      },
+      _module: {
+        type: loaderContext._module.type,
+        identifier: loaderContext._module.identifier(),
+        matchResource: normalModule == null ? void 0 : normalModule.matchResource,
+        request: normalModule == null ? void 0 : normalModule.request,
+        userRequest: normalModule == null ? void 0 : normalModule.userRequest,
+        rawRequest: normalModule == null ? void 0 : normalModule.rawRequest
+      }
+    };
+    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 "ImportModule" /* ImportModule */: {
+            return loaderContext.importModule(args[0], args[1]);
+          }
+          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;
+          }
+          case "CompilationGetPath" /* CompilationGetPath */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getPath(filename2, data);
+          }
+          case "CompilationGetPathWithInfo" /* CompilationGetPathWithInfo */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getPathWithInfo(filename2, data);
+          }
+          case "CompilationGetAssetPath" /* CompilationGetAssetPath */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getAssetPath(filename2, data);
+          }
+          case "CompilationGetAssetPathWithInfo" /* CompilationGetAssetPathWithInfo */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getAssetPathWithInfo(
+              filename2,
+              data
+            );
+          }
+          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 +6350,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 +6393,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 +6405,10 @@ function parsePathQueryFragment(str) {
 
 // src/config/adapterRuleUse.ts
 var BUILTIN_LOADER_PREFIX = "builtin:";
-function createRawModuleRuleUses(uses, path12, 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, path12, options);
+  return createRawModuleRuleUsesImpl(allUses, path13, options);
 }
 var getSwcLoaderOptions = (options, _) => {
   if (options && typeof options === "object") {
@@ -6079,7 +6449,7 @@ function getBuiltinLoaderOptions(identifier, o, options) {
   }
   return o;
 }
-function createRawModuleRuleUsesImpl(uses, path12, options) {
+function createRawModuleRuleUsesImpl(uses, path13, options) {
   if (!uses.length) {
     return [];
   }
@@ -6094,7 +6464,7 @@ function createRawModuleRuleUsesImpl(uses, path12, options) {
     return {
       loader: resolveStringifyLoaders(
         use,
-        `${path12}[${index}]`,
+        `${path13}[${index}]`,
         options.compiler,
         isBuiltin
       ),
@@ -6102,20 +6472,33 @@ function createRawModuleRuleUsesImpl(uses, path12, options) {
     };
   });
 }
-function resolveStringifyLoaders(use, path12, 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 = path12}`;
+  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);
     }
@@ -6280,7 +6663,7 @@ function tryMatch(payload, condition) {
   }
   return false;
 }
-var getRawModuleRule = (rule, path12, options, upperType) => {
+var getRawModuleRule = (rule, path13, options, upperType) => {
   if (rule.loader) {
     rule.use = [
       {
@@ -6298,7 +6681,7 @@ var getRawModuleRule = (rule, path12, options, upperType) => {
         compiler: options.compiler
       };
       const uses = use(context2);
-      return createRawModuleRuleUses(uses ?? [], `${path12}.use`, options);
+      return createRawModuleRuleUses(uses ?? [], `${path13}.use`, options);
     };
   }
   const rawModuleRule = {
@@ -6326,7 +6709,7 @@ var getRawModuleRule = (rule, path12, 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 ?? [], `${path12}.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,
@@ -6335,7 +6718,7 @@ var getRawModuleRule = (rule, path12, options, upperType) => {
     oneOf: rule.oneOf ? rule.oneOf.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
-        `${path12}.oneOf[${index}]`,
+        `${path13}.oneOf[${index}]`,
         options,
         rule2.type ?? upperType
       )
@@ -6343,7 +6726,7 @@ var getRawModuleRule = (rule, path12, options, upperType) => {
     rules: rule.rules ? rule.rules.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
-        `${path12}.rules[${index}]`,
+        `${path13}.rules[${index}]`,
         options,
         rule2.type ?? upperType
       )
@@ -6357,11 +6740,11 @@ var getRawModuleRule = (rule, path12, options, upperType) => {
     delete rawModuleRule.resourceFragment;
     rawModuleRule.rspackResource = getRawRuleSetCondition(
       (resourceQueryFragment) => {
-        const { path: path13, query, fragment } = parseResource(resourceQueryFragment);
-        if (rule.test && !tryMatch(path13, rule.test)) {
+        const { path: path14, query, fragment } = parseResource(resourceQueryFragment);
+        if (rule.test && !tryMatch(path14, rule.test)) {
           return false;
         }
-        if (rule.resource && !tryMatch(path13, rule.resource)) {
+        if (rule.resource && !tryMatch(path14, rule.resource)) {
           return false;
         }
         if (rule.resourceQuery && !tryMatch(query, rule.resourceQuery)) {
@@ -6671,7 +7054,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_path10 = __toESM(require("path"));
+var import_node_path11 = __toESM(require("path"));
 
 // src/ModuleTypeConstants.ts
 var JSON_MODULE_TYPE = "json";
@@ -7022,13 +7405,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
@@ -7038,7 +7421,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 || {};
@@ -7686,18 +8069,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 = {
@@ -7754,11 +8133,11 @@ function isNonEmptyArray(value) {
   return value.length !== 0;
 }
 var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
-function joinPath(path12) {
-  if (path12.length === 1) {
-    return path12[0].toString();
+function joinPath(path13) {
+  if (path13.length === 1) {
+    return path13[0].toString();
   }
-  return path12.reduce((acc, item) => {
+  return path13.reduce((acc, item) => {
     if (typeof item === "number") {
       return acc + "[" + item.toString() + "]";
     }
@@ -8108,10 +8487,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}\``
@@ -8248,7 +8627,7 @@ var HttpExternalsRspackPlugin = create2(
 );
 
 // src/builtin-plugin/HttpUriPlugin.ts
-var import_node_path7 = __toESM(require("path"));
+var import_node_path8 = __toESM(require("path"));
 var import_binding37 = require("@rspack/binding");
 var defaultHttpClient = (url2, headers) => {
   return fetch(url2, { headers }).then((response) => {
@@ -8274,7 +8653,7 @@ var HttpUriPlugin = class extends RspackBuiltinPlugin {
   }
   raw(compiler) {
     const { options } = this;
-    const lockfileLocation = options.lockfileLocation ?? import_node_path7.default.join(
+    const lockfileLocation = options.lockfileLocation ?? import_node_path8.default.join(
       compiler.context,
       compiler.name ? `${compiler.name}.rspack.lock` : "rspack.lock"
     );
@@ -8335,11 +8714,7 @@ var JavascriptModulesPlugin = class extends RspackBuiltinPlugin {
     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 = {
@@ -8393,11 +8768,11 @@ var lazyCompilationMiddleware = (compiler, userOptions = {}) => {
   const activeModules = /* @__PURE__ */ new Map();
   const filesByKey = /* @__PURE__ */ new Map();
   new BuiltinLazyCompilationPlugin(
-    ({ module: module2, path: path12 }) => {
+    ({ 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, path12);
+      filesByKey.set(key, path13);
       const active = activeModules.get(key) === true;
       return {
         client: `${options.client || getDefaultClient(compiler)}?${encodeURIComponent((options.serverUrl ?? "") + LAZY_COMPILATION_PREFIX)}`,
@@ -8725,11 +9100,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 = {
@@ -9153,13 +9524,13 @@ var import_binding73 = require("@rspack/binding");
 var LibManifestPlugin = create2(
   import_binding73.BuiltinPluginName.LibManifestPlugin,
   (options) => {
-    const { context: context2, entryOnly, format: format3, name: name2, path: path12, type } = options;
+    const { context: context2, entryOnly, format: format3, name: name2, path: path13, type } = options;
     return {
       context: context2,
       entryOnly,
       format: format3,
       name: name2,
-      path: path12,
+      path: path13,
       type
     };
   }
@@ -9209,11 +9580,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 = {
@@ -9300,7 +9667,7 @@ 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_path8 = require("path");
+var import_node_path9 = require("path");
 var import_binding77 = require("@rspack/binding");
 var import_zod4 = require("../compiled/zod/index.js");
 var PLUGIN_NAME2 = "SubresourceIntegrityPlugin";
@@ -9382,7 +9749,7 @@ var SubresourceIntegrityPlugin = class extends NativeSubresourceIntegrityPlugin
     for (const asset of assets.js) {
       jsIntegrity.push(
         this.getIntegrityChecksumForAsset(
-          (0, import_node_path8.relative)(publicPath2, decodeURIComponent(asset))
+          (0, import_node_path9.relative)(publicPath2, decodeURIComponent(asset))
         )
       );
     }
@@ -9390,7 +9757,7 @@ var SubresourceIntegrityPlugin = class extends NativeSubresourceIntegrityPlugin
     for (const asset of assets.css) {
       cssIntegrity.push(
         this.getIntegrityChecksumForAsset(
-          (0, import_node_path8.relative)(publicPath2, decodeURIComponent(asset))
+          (0, import_node_path9.relative)(publicPath2, decodeURIComponent(asset))
         )
       );
     }
@@ -9410,10 +9777,10 @@ var SubresourceIntegrityPlugin = class extends NativeSubresourceIntegrityPlugin
     if (!tagSrc) {
       return;
     }
-    const src = (0, import_node_path8.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_path8.join)(outputPath, src))
+      (0, import_node_fs2.readFileSync)((0, import_node_path9.join)(outputPath, src))
     );
     tag.attributes.crossorigin = crossOriginLoading2 || "anonymous";
   }
@@ -9513,8 +9880,8 @@ function computeIntegrity(hashFuncNames, source) {
   ).join(" ");
   return result2;
 }
-function normalizePath(path12) {
-  return path12.replace(/\?.*$/, "").split(import_node_path8.sep).join("/");
+function normalizePath(path13) {
+  return path13.replace(/\?.*$/, "").split(import_node_path9.sep).join("/");
 }
 
 // src/builtin-plugin/ModuleInfoHeaderPlugin.ts
@@ -9859,13 +10226,13 @@ __export(browserslistTargetHandler_exports, {
   load: () => load,
   resolve: () => resolve
 });
-var import_node_path9 = __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_path9.default.isAbsolute(input)) {
+  if (import_node_path10.default.isAbsolute(input)) {
     const [, configPath, env] = inputRx.exec(input) || [];
     return { configPath, env };
   }
@@ -10552,6 +10919,7 @@ var applyExperimentsDefaults = (experiments3, { production, development }) => {
   }
   D(experiments3, "rspackFuture", {});
   D(experiments3, "parallelCodeSplitting", true);
+  D(experiments3, "parallelLoader", false);
 };
 var applybundlerInfoDefaults = (rspackFuture, library3) => {
   if (typeof rspackFuture === "object") {
@@ -10814,7 +11182,7 @@ var applyOutputDefaults = (output2, {
       }
     );
     if (libraryName2) return libraryName2;
-    const pkgPath = import_node_path10.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 || "";
@@ -10870,7 +11238,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_path10.default.join(process.cwd(), "dist"));
+  F(output2, "path", () => import_node_path11.default.join(process.cwd(), "dist"));
   F(output2, "pathinfo", () => development);
   D(
     output2,
@@ -11345,7 +11713,7 @@ var getPnpDefault = () => {
 };
 
 // src/config/normalization.ts
-var import_node_path11 = __toESM(require("path"));
+var import_node_path12 = __toESM(require("path"));
 var import_node_util5 = __toESM(require("util"));
 var getNormalizedRspackOptions = (config2) => {
   return {
@@ -11535,7 +11903,7 @@ var getNormalizedRspackOptions = (config2) => {
           type: "persistent",
           buildDependencies: nestedArray(
             cache.buildDependencies,
-            (deps) => deps.map((d) => import_node_path11.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: {
@@ -11547,7 +11915,7 @@ var getNormalizedRspackOptions = (config2) => {
           },
           storage: {
             type: "filesystem",
-            directory: import_node_path11.default.resolve(
+            directory: import_node_path12.default.resolve(
               config2.context || process.cwd(),
               ((_a = cache.storage) == null ? void 0 : _a.directory) || "node_modules/.cache/rspack"
             )
@@ -11579,7 +11947,8 @@ var getNormalizedRspackOptions = (config2) => {
         } : options
       ),
       parallelCodeSplitting: experiments3.parallelCodeSplitting,
-      buildHttp: experiments3.buildHttp
+      buildHttp: experiments3.buildHttp,
+      parallelLoader: experiments3.parallelLoader
     })),
     watch: config2.watch,
     watchOptions: cloneObject(config2.watchOptions),
@@ -11685,14 +12054,14 @@ var Resolver = class _Resolver {
   constructor(binding14) {
     this.binding = binding14;
   }
-  resolveSync(context2, path12, request) {
-    const data = this.binding.resolveSync(path12, request);
+  resolveSync(context2, path13, request) {
+    const data = this.binding.resolveSync(path13, request);
     if (data === false) return data;
     return data.resource;
   }
-  resolve(context2, path12, request, resolveContext, callback) {
+  resolve(context2, path13, request, resolveContext, callback) {
     try {
-      const data = this.binding.resolveSync(path12, request);
+      const data = this.binding.resolveSync(path13, request);
       if (data === false) {
         callback(null, false);
         return;
@@ -12038,7 +12407,7 @@ var Watching = class {
 
 // src/util/bindingVersionCheck.ts
 var import_node_fs4 = require("fs");
-var import_node_path12 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var NodePlatformArchToAbi = {
   android: {
     arm64: "",
@@ -12110,7 +12479,7 @@ var checkVersion = () => {
   }
   let ADDON_VERSION;
   try {
-    const BINDING_PKG_DIR = import_node_path12.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(
@@ -12802,15 +13171,17 @@ var createCompilationHooksRegisters = (getCompiler, createTap, createMapTap) =>
       function(queried) {
         return function({
           chunk: chunkBinding,
+          allRuntimeRequirements,
           runtimeRequirements
         }) {
           const set = __from_binding_runtime_globals(runtimeRequirements);
+          const all = __from_binding_runtime_globals(allRuntimeRequirements);
           const chunk = Chunk.__from_binding(chunkBinding);
           for (const r of set) {
-            queried.for(r).call(chunk, set);
+            queried.for(r).call(chunk, all);
           }
           return {
-            runtimeRequirements: __to_binding_runtime_globals(set)
+            allRuntimeRequirements: __to_binding_runtime_globals(all)
           };
         };
       }
@@ -13678,7 +14049,7 @@ var Compiler = class _Compiler {
         return finalCallback(null, stats);
       });
     };
-    const run = () => {
+    const run2 = () => {
       this.hooks.beforeRun.callAsync(this, (err) => {
         if (err) {
           return finalCallback(err);
@@ -13695,10 +14066,10 @@ var Compiler = class _Compiler {
       this.cache.endIdle((err) => {
         if (err) return callback(err);
         this.idle = false;
-        run();
+        run2();
       });
     } else {
-      run();
+      run2();
     }
   }
   runAsChild(callback) {
@@ -14550,7 +14921,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,
@@ -14664,7 +15035,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)
@@ -15183,17 +15554,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 path12 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+          const path13 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
           const keys = [];
           if (groupAssetsByPath) {
             keys.push(".");
             if (extension)
               keys.push(
-                path12.length ? `${path12.join("/")}/*${extension}` : `*${extension}`
+                path13.length ? `${path13.join("/")}/*${extension}` : `*${extension}`
               );
-            while (path12.length > 0) {
-              keys.push(`${path12.join("/")}/`);
-              path12.pop();
+            while (path13.length > 0) {
+              keys.push(`${path13.join("/")}/`);
+              path13.pop();
             }
           } else {
             if (extension) keys.push(`*${extension}`);
@@ -15379,16 +15750,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 path12 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+          const path13 = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
           const keys = [];
           if (groupModulesByPath) {
             if (extension)
               keys.push(
-                path12.length ? `${path12.join("/")}/*${extension}` : `*${extension}`
+                path13.length ? `${path13.join("/")}/*${extension}` : `*${extension}`
               );
-            while (path12.length > 0) {
-              keys.push(`${path12.join("/")}/`);
-              path12.pop();
+            while (path13.length > 0) {
+              keys.push(`${path13.join("/")}/`);
+              path13.pop();
             }
           } else {
             if (extension) keys.push(`*${extension}`);
@@ -18967,7 +19338,7 @@ var NodeTemplatePlugin = class {
 };
 
 // src/config/zod.ts
-var import_node_path13 = __toESM(require("path"));
+var import_node_path14 = __toESM(require("path"));
 var import_zod8 = require("../compiled/zod/index.js");
 
 // src/config/utils.ts
@@ -19125,7 +19496,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_path13.default.isAbsolute(val),
+  (val) => import_node_path14.default.isAbsolute(val),
   (val) => ({
     message: `The provided value ${JSON.stringify(val)} must be an absolute path.`
   })
@@ -19224,7 +19595,7 @@ var entryDynamic = import_zod8.z.function().returns(
   entryStatic.or(import_zod8.z.promise(entryStatic))
 );
 var entry = entryStatic.or(entryDynamic);
-var path11 = 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();
@@ -19298,7 +19669,7 @@ var environment = import_zod8.z.strictObject({
   templateLiteral: import_zod8.z.boolean().optional()
 });
 var output = import_zod8.z.strictObject({
-  path: path11.optional(),
+  path: path12.optional(),
   pathinfo: pathinfo.optional(),
   clean: clean.optional(),
   publicPath: publicPath.optional(),
@@ -19403,7 +19774,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
@@ -20089,7 +20461,8 @@ var experiments = import_zod8.z.strictObject({
   parallelCodeSplitting: import_zod8.z.boolean().optional(),
   futureDefaults: import_zod8.z.boolean().optional(),
   rspackFuture: rspackFutureOptions.optional(),
-  buildHttp: buildHttpOptions.optional()
+  buildHttp: buildHttpOptions.optional(),
+  parallelLoader: import_zod8.z.boolean().optional()
 });
 var watch = import_zod8.z.boolean();
 var watchOptions = import_zod8.z.strictObject({