@rspack/core 1.1.0-beta.0 → 1.1.0

package/dist/index.js

@@ -143,9 +143,9 @@ var require_lib = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/enhanced-resolve@5.12.0/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js
+// ../../node_modules/.pnpm/enhanced-resolve@5.17.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js
 var require_CachedInputFileSystem = __commonJS({
-  "../../node_modules/.pnpm/enhanced-resolve@5.12.0/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js"(exports2, module2) {
+  "../../node_modules/.pnpm/enhanced-resolve@5.17.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js"(exports2, module2) {
     "use strict";
     var nextTick = require("process").nextTick;
     var dirname4 = (path10) => {
@@ -177,46 +177,81 @@ var require_CachedInputFileSystem = __commonJS({
     };
     var OperationMergerBackend = class {
       /**
-       * @param {any} provider async method
-       * @param {any} syncProvider sync method
-       * @param {any} providerContext call context for the provider methods
+       * @param {Function | undefined} provider async method in filesystem
+       * @param {Function | undefined} syncProvider sync method in filesystem
+       * @param {BaseFileSystem} providerContext call context for the provider methods
        */
       constructor(provider, syncProvider, providerContext) {
         this._provider = provider;
         this._syncProvider = syncProvider;
         this._providerContext = providerContext;
         this._activeAsyncOperations = /* @__PURE__ */ new Map();
-        this.provide = this._provider ? (path10, options, callback) => {
-          if (typeof options === "function") {
-            callback = options;
-            options = void 0;
-          }
-          if (options) {
-            return this._provider.call(
-              this._providerContext,
+        this.provide = this._provider ? (
+          /**
+           * @param {PathLike | PathOrFileDescriptor} path path
+           * @param {object | FileSystemCallback<any> | undefined} options options
+           * @param {FileSystemCallback<any>=} callback callback
+           * @returns {any} result
+           */
+          (path10, options, callback) => {
+            if (typeof options === "function") {
+              callback = /** @type {FileSystemCallback<any>} */
+              options;
+              options = void 0;
+            }
+            if (typeof path10 !== "string" && !Buffer.isBuffer(path10) && !(path10 instanceof URL) && typeof path10 !== "number") {
+              callback(
+                new TypeError("path must be a string, Buffer, URL or number")
+              );
+              return;
+            }
+            if (options) {
+              return (
+                /** @type {Function} */
+                this._provider.call(
+                  this._providerContext,
+                  path10,
+                  options,
+                  callback
+                )
+              );
+            }
+            let callbacks = this._activeAsyncOperations.get(path10);
+            if (callbacks) {
+              callbacks.push(callback);
+              return;
+            }
+            this._activeAsyncOperations.set(path10, callbacks = [callback]);
+            provider(
               path10,
-              options,
-              callback
+              /**
+               * @param {Error} err error
+               * @param {any} result result
+               */
+              (err, result2) => {
+                this._activeAsyncOperations.delete(path10);
+                runCallbacks(callbacks, err, result2);
+              }
             );
           }
-          if (typeof path10 !== "string") {
-            callback(new TypeError("path must be a string"));
-            return;
-          }
-          let callbacks = this._activeAsyncOperations.get(path10);
-          if (callbacks) {
-            callbacks.push(callback);
-            return;
+        ) : null;
+        this.provideSync = this._syncProvider ? (
+          /**
+           * @param {PathLike | PathOrFileDescriptor} path path
+           * @param {object=} options options
+           * @returns {any} result
+           */
+          (path10, options) => {
+            return (
+              /** @type {Function} */
+              this._syncProvider.call(
+                this._providerContext,
+                path10,
+                options
+              )
+            );
           }
-          this._activeAsyncOperations.set(path10, callbacks = [callback]);
-          provider(path10, (err, result2) => {
-            this._activeAsyncOperations.delete(path10);
-            runCallbacks(callbacks, err, result2);
-          });
-        } : null;
-        this.provideSync = this._syncProvider ? (path10, options) => {
-          return this._syncProvider.call(this._providerContext, path10, options);
-        } : null;
+        ) : null;
       }
       purge() {
       }
@@ -229,9 +264,9 @@ var require_CachedInputFileSystem = __commonJS({
     var CacheBackend = class {
       /**
        * @param {number} duration max cache duration of items
-       * @param {any} provider async method
-       * @param {any} syncProvider sync method
-       * @param {any} providerContext call context for the provider methods
+       * @param {function | undefined} provider async method
+       * @param {function | undefined} syncProvider sync method
+       * @param {BaseFileSystem} providerContext call context for the provider methods
        */
       constructor(duration, provider, syncProvider, providerContext) {
         this._duration = duration;
@@ -251,75 +286,132 @@ var require_CachedInputFileSystem = __commonJS({
         this.provide = provider ? this.provide.bind(this) : null;
         this.provideSync = syncProvider ? this.provideSync.bind(this) : null;
       }
+      /**
+       * @param {PathLike | PathOrFileDescriptor} path path
+       * @param {any} options options
+       * @param {FileSystemCallback<any>} callback callback
+       * @returns {void}
+       */
       provide(path10, options, callback) {
         if (typeof options === "function") {
           callback = options;
           options = void 0;
         }
-        if (typeof path10 !== "string") {
-          callback(new TypeError("path must be a string"));
+        if (typeof path10 !== "string" && !Buffer.isBuffer(path10) && !(path10 instanceof URL) && typeof path10 !== "number") {
+          callback(new TypeError("path must be a string, Buffer, URL or number"));
           return;
         }
+        const strPath = typeof path10 !== "string" ? path10.toString() : path10;
         if (options) {
-          return this._provider.call(
-            this._providerContext,
-            path10,
-            options,
-            callback
+          return (
+            /** @type {Function} */
+            this._provider.call(
+              this._providerContext,
+              path10,
+              options,
+              callback
+            )
           );
         }
         if (this._mode === STORAGE_MODE_SYNC) {
           this._enterAsyncMode();
         }
-        let cacheEntry = this._data.get(path10);
+        let cacheEntry = this._data.get(strPath);
         if (cacheEntry !== void 0) {
           if (cacheEntry.err) return nextTick(callback, cacheEntry.err);
           return nextTick(callback, null, cacheEntry.result);
         }
-        let callbacks = this._activeAsyncOperations.get(path10);
+        let callbacks = this._activeAsyncOperations.get(strPath);
         if (callbacks !== void 0) {
           callbacks.push(callback);
           return;
         }
-        this._activeAsyncOperations.set(path10, callbacks = [callback]);
-        this._provider.call(this._providerContext, path10, (err, result2) => {
-          this._activeAsyncOperations.delete(path10);
-          this._storeResult(path10, err, result2);
-          this._enterAsyncMode();
-          runCallbacks(callbacks, err, result2);
-        });
+        this._activeAsyncOperations.set(strPath, callbacks = [callback]);
+        this._provider.call(
+          this._providerContext,
+          path10,
+          /**
+           * @param {Error | null} err error
+           * @param {any} [result] result
+           */
+          (err, result2) => {
+            this._activeAsyncOperations.delete(strPath);
+            this._storeResult(strPath, err, result2);
+            this._enterAsyncMode();
+            runCallbacks(
+              /** @type {FileSystemCallback<any>[]} */
+              callbacks,
+              err,
+              result2
+            );
+          }
+        );
       }
+      /**
+       * @param {PathLike | PathOrFileDescriptor} path path
+       * @param {any} options options
+       * @returns {any} result
+       */
       provideSync(path10, options) {
-        if (typeof path10 !== "string") {
+        if (typeof path10 !== "string" && !Buffer.isBuffer(path10) && !(path10 instanceof URL) && typeof path10 !== "number") {
           throw new TypeError("path must be a string");
         }
+        const strPath = typeof path10 !== "string" ? path10.toString() : path10;
         if (options) {
-          return this._syncProvider.call(this._providerContext, path10, options);
+          return (
+            /** @type {Function} */
+            this._syncProvider.call(
+              this._providerContext,
+              path10,
+              options
+            )
+          );
         }
         if (this._mode === STORAGE_MODE_SYNC) {
           this._runDecays();
         }
-        let cacheEntry = this._data.get(path10);
+        let cacheEntry = this._data.get(strPath);
         if (cacheEntry !== void 0) {
           if (cacheEntry.err) throw cacheEntry.err;
           return cacheEntry.result;
         }
-        const callbacks = this._activeAsyncOperations.get(path10);
-        this._activeAsyncOperations.delete(path10);
+        const callbacks = this._activeAsyncOperations.get(strPath);
+        this._activeAsyncOperations.delete(strPath);
         let result2;
         try {
-          result2 = this._syncProvider.call(this._providerContext, path10);
+          result2 = /** @type {Function} */
+          this._syncProvider.call(
+            this._providerContext,
+            path10
+          );
         } catch (err) {
-          this._storeResult(path10, err, void 0);
+          this._storeResult(
+            strPath,
+            /** @type {Error} */
+            err,
+            void 0
+          );
           this._enterSyncModeWhenIdle();
-          if (callbacks) runCallbacks(callbacks, err, void 0);
+          if (callbacks) {
+            runCallbacks(
+              callbacks,
+              /** @type {Error} */
+              err,
+              void 0
+            );
+          }
           throw err;
         }
-        this._storeResult(path10, void 0, result2);
+        this._storeResult(strPath, null, result2);
         this._enterSyncModeWhenIdle();
-        if (callbacks) runCallbacks(callbacks, void 0, result2);
+        if (callbacks) {
+          runCallbacks(callbacks, null, result2);
+        }
         return result2;
       }
+      /**
+       * @param {string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set<string | URL | Buffer | number>} [what] what to purge
+       */
       purge(what) {
         if (!what) {
           if (this._mode !== STORAGE_MODE_IDLE) {
@@ -329,9 +421,10 @@ var require_CachedInputFileSystem = __commonJS({
             }
             this._enterIdleMode();
           }
-        } else if (typeof what === "string") {
+        } else if (typeof what === "string" || Buffer.isBuffer(what) || what instanceof URL || typeof what === "number") {
+          const strWhat = typeof what !== "string" ? what.toString() : what;
           for (let [key, data] of this._data) {
-            if (key.startsWith(what)) {
+            if (key.startsWith(strWhat)) {
               this._data.delete(key);
               data.level.delete(key);
             }
@@ -342,7 +435,8 @@ var require_CachedInputFileSystem = __commonJS({
         } else {
           for (let [key, data] of this._data) {
             for (const item of what) {
-              if (key.startsWith(item)) {
+              const strItem = typeof item !== "string" ? item.toString() : item;
+              if (key.startsWith(strItem)) {
                 this._data.delete(key);
                 data.level.delete(key);
                 break;
@@ -354,19 +448,29 @@ var require_CachedInputFileSystem = __commonJS({
           }
         }
       }
+      /**
+       * @param {string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set<string | URL | Buffer | number>} [what] what to purge
+       */
       purgeParent(what) {
         if (!what) {
           this.purge();
-        } else if (typeof what === "string") {
-          this.purge(dirname4(what));
+        } else if (typeof what === "string" || Buffer.isBuffer(what) || what instanceof URL || typeof what === "number") {
+          const strWhat = typeof what !== "string" ? what.toString() : what;
+          this.purge(dirname4(strWhat));
         } else {
           const set = /* @__PURE__ */ new Set();
           for (const item of what) {
-            set.add(dirname4(item));
+            const strItem = typeof item !== "string" ? item.toString() : item;
+            set.add(dirname4(strItem));
           }
           this.purge(set);
         }
       }
+      /**
+       * @param {string} path path
+       * @param {Error | null} err error
+       * @param {any} result result
+       */
       _storeResult(path10, err, result2) {
         if (this._data.has(path10)) return;
         const level = this._levels[this._currentLevel];
@@ -406,7 +510,11 @@ var require_CachedInputFileSystem = __commonJS({
             break;
           case STORAGE_MODE_SYNC:
             this._runDecays();
-            if (this._mode === STORAGE_MODE_IDLE) return;
+            if (
+              /** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC}*/
+              this._mode === STORAGE_MODE_IDLE
+            )
+              return;
             timeout = Math.max(
               0,
               /** @type {number} */
@@ -441,6 +549,10 @@ var require_CachedInputFileSystem = __commonJS({
       return new OperationMergerBackend(provider, syncProvider, providerContext);
     };
     module2.exports = class CachedInputFileSystem {
+      /**
+       * @param {BaseFileSystem} fileSystem file system
+       * @param {number} duration duration in ms files are cached
+       */
       constructor(fileSystem, duration) {
         this.fileSystem = fileSystem;
         this._lstatBackend = createBackend(
@@ -493,7 +605,12 @@ var require_CachedInputFileSystem = __commonJS({
         readFileSync2;
         this._readJsonBackend = createBackend(
           duration,
-          this.fileSystem.readJson || this.readFile && ((path10, callback) => {
+          // prettier-ignore
+          this.fileSystem.readJson || this.readFile && /**
+           * @param {string} path path
+           * @param {FileSystemCallback<any>} callback
+           */
+          ((path10, callback) => {
             this.readFile(path10, (err, buffer) => {
               if (err) return callback(err);
               if (!buffer || buffer.length === 0)
@@ -502,12 +619,20 @@ var require_CachedInputFileSystem = __commonJS({
               try {
                 data = JSON.parse(buffer.toString("utf-8"));
               } catch (e) {
-                return callback(e);
+                return callback(
+                  /** @type {Error} */
+                  e
+                );
               }
               callback(null, data);
             });
           }),
-          this.fileSystem.readJsonSync || this.readFileSync && ((path10) => {
+          // prettier-ignore
+          this.fileSystem.readJsonSync || this.readFileSync && /**
+           * @param {string} path path
+           * @returns {any} result
+           */
+          ((path10) => {
             const buffer = this.readFileSync(path10);
             const data = JSON.parse(buffer.toString("utf-8"));
             return data;
@@ -532,7 +657,22 @@ var require_CachedInputFileSystem = __commonJS({
         const readlinkSync = this._readlinkBackend.provideSync;
         this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */
         readlinkSync;
+        this._realpathBackend = createBackend(
+          duration,
+          this.fileSystem.realpath,
+          this.fileSystem.realpathSync,
+          this.fileSystem
+        );
+        const realpath = this._realpathBackend.provide;
+        this.realpath = /** @type {FileSystem["realpath"]} */
+        realpath;
+        const realpathSync = this._realpathBackend.provideSync;
+        this.realpathSync = /** @type {SyncFileSystem["realpathSync"]} */
+        realpathSync;
       }
+      /**
+       * @param {string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set<string | URL | Buffer | number>} [what] what to purge
+       */
       purge(what) {
         this._statBackend.purge(what);
         this._lstatBackend.purge(what);
@@ -540,6 +680,7 @@ var require_CachedInputFileSystem = __commonJS({
         this._readFileBackend.purge(what);
         this._readlinkBackend.purge(what);
         this._readJsonBackend.purge(what);
+        this._realpathBackend.purge(what);
       }
     };
   }
@@ -996,14 +1137,28 @@ var Dependency = class _Dependency {
 // src/DependenciesBlock.ts
 var DependenciesBlock = class _DependenciesBlock {
   #binding;
-  constructor(binding3) {
-    this.#binding = binding3;
+  static __from_binding(binding3) {
+    return new _DependenciesBlock(binding3);
   }
-  get dependencies() {
-    return this.#binding.dependencies.map((d) => Dependency.__from_binding(d));
+  static __to_binding(block) {
+    return block.#binding;
   }
-  get blocks() {
-    return this.#binding.blocks.map((b) => new _DependenciesBlock(b));
+  constructor(binding3) {
+    this.#binding = binding3;
+    Object.defineProperties(this, {
+      dependencies: {
+        enumerable: true,
+        get() {
+          return binding3.dependencies.map((d) => Dependency.__from_binding(d));
+        }
+      },
+      blocks: {
+        enumerable: true,
+        get() {
+          return binding3.blocks.map((b) => _DependenciesBlock.__from_binding(b));
+        }
+      }
+    });
   }
 };
 
@@ -1083,21 +1238,10 @@ var ContextModuleFactoryBeforeResolveData = class _ContextModuleFactoryBeforeRes
       regExp: {
         enumerable: true,
         get() {
-          if (!binding3.regExp) {
-            return void 0;
-          }
-          const { source, flags } = binding3.regExp;
-          return new RegExp(source, flags);
+          return binding3.regExp;
         },
         set(val) {
-          if (!val) {
-            binding3.regExp = void 0;
-            return;
-          }
-          binding3.regExp = {
-            source: val.source,
-            flags: val.flags
-          };
+          binding3.regExp = val;
         }
       },
       recursive: {
@@ -1153,21 +1297,10 @@ var ContextModuleFactoryAfterResolveData = class _ContextModuleFactoryAfterResol
       regExp: {
         enumerable: true,
         get() {
-          if (!binding3.regExp) {
-            return void 0;
-          }
-          const { source, flags } = binding3.regExp;
-          return new RegExp(source, flags);
+          return binding3.regExp;
         },
         set(val) {
-          if (!val) {
-            binding3.regExp = void 0;
-            return;
-          }
-          binding3.regExp = {
-            source: val.source,
-            flags: val.flags
-          };
+          binding3.regExp = val;
         }
       },
       recursive: {
@@ -1190,46 +1323,128 @@ var ContextModuleFactoryAfterResolveData = class _ContextModuleFactoryAfterResol
     });
   }
 };
+var MODULE_MAPPINGS = /* @__PURE__ */ new WeakMap();
 var Module = class _Module {
   #inner;
-  #originalSource;
-  static __from_binding(module2, compilation) {
-    return new _Module(module2, compilation);
+  static __from_binding(binding3, compilation) {
+    let module2 = MODULE_MAPPINGS.get(binding3);
+    if (module2) {
+      return module2;
+    }
+    module2 = new _Module(binding3, compilation);
+    MODULE_MAPPINGS.set(binding3, module2);
+    return module2;
   }
   constructor(module2, compilation) {
     this.#inner = module2;
-    this.type = module2.type;
-    this.layer = module2.layer ?? null;
-    this.context = module2.context;
-    this.resource = module2.resource;
-    this.request = module2.request;
-    this.userRequest = module2.userRequest;
-    this.rawRequest = module2.rawRequest;
-    this.factoryMeta = module2.factoryMeta;
-    const customModule = compilation == null ? void 0 : compilation.__internal__getCustomModule(
-      module2.moduleIdentifier
-    );
-    this.buildInfo = (customModule == null ? void 0 : customModule.buildInfo) || {};
-    this.buildMeta = (customModule == null ? void 0 : customModule.buildMeta) || {};
     Object.defineProperties(this, {
+      type: {
+        enumerable: true,
+        get() {
+          return module2.type || null;
+        }
+      },
+      layer: {
+        enumerable: true,
+        get() {
+          return module2.layer;
+        }
+      },
+      context: {
+        enumerable: true,
+        get() {
+          return module2.context;
+        }
+      },
+      resource: {
+        enumerable: true,
+        get() {
+          return module2.resource;
+        }
+      },
+      request: {
+        enumerable: true,
+        get() {
+          return module2.request;
+        }
+      },
+      userRequest: {
+        enumerable: true,
+        get() {
+          return module2.userRequest;
+        },
+        set(val) {
+          module2.userRequest = val;
+        }
+      },
+      rawRequest: {
+        enumerable: true,
+        get() {
+          return module2.rawRequest;
+        }
+      },
+      factoryMeta: {
+        enumerable: true,
+        get() {
+          return module2.factoryMeta;
+        }
+      },
       modules: {
         enumerable: true,
         get() {
-          if (module2 instanceof import_binding4.ModuleDto) {
+          if (module2 instanceof import_binding4.JsModule) {
             return module2.modules ? module2.modules.map((m) => _Module.__from_binding(m)) : void 0;
           }
           return void 0;
         }
+      },
+      buildInfo: {
+        enumerable: true,
+        get() {
+          const customModule = compilation == null ? void 0 : compilation.__internal__getCustomModule(
+            module2.moduleIdentifier
+          );
+          return (customModule == null ? void 0 : customModule.buildInfo) || {};
+        }
+      },
+      buildMeta: {
+        enumerable: true,
+        get() {
+          const customModule = compilation == null ? void 0 : compilation.__internal__getCustomModule(
+            module2.moduleIdentifier
+          );
+          return (customModule == null ? void 0 : customModule.buildMeta) || {};
+        }
+      },
+      blocks: {
+        enumerable: true,
+        get() {
+          if ("blocks" in module2) {
+            return module2.blocks.map((b) => DependenciesBlock.__from_binding(b));
+          }
+          return [];
+        }
+      },
+      dependencies: {
+        enumerable: true,
+        get() {
+          if ("dependencies" in module2) {
+            return module2.dependencies.map((d) => Dependency.__from_binding(d));
+          }
+          return [];
+        }
+      },
+      useSourceMap: {
+        enumerable: true,
+        get() {
+          return module2.useSourceMap;
+        }
       }
     });
   }
   originalSource() {
-    if (this.#originalSource) return this.#originalSource;
     if (this.#inner.originalSource) {
-      this.#originalSource = JsSource.__from_binding(
-        this.#inner.originalSource
-      );
-      return this.#originalSource;
+      return JsSource.__from_binding(this.#inner.originalSource);
     }
     return null;
   }
@@ -1242,12 +1457,6 @@ var Module = class _Module {
     }
     return null;
   }
-  get blocks() {
-    if ("blocks" in this.#inner) {
-      return this.#inner.blocks.map((b) => new DependenciesBlock(b));
-    }
-    return [];
-  }
   size(type) {
     if ("size" in this.#inner) {
       return this.#inner.size(type);
@@ -1448,7 +1657,8 @@ var RuntimeModule = class {
       name: module2.name,
       stage: module2.stage,
       generator: module2.generate.bind(module2),
-      cacheable: !(module2.fullHash || module2.dependentHash),
+      fullHash: module2.fullHash,
+      dependentHash: module2.dependentHash,
       isolate: module2.shouldIsolate()
     };
   }
@@ -5977,7 +6187,13 @@ async function runLoaders(compiler, context2) {
               if (res.cacheable === false) {
                 this.cacheable(false);
               }
-              resolve2(compiler.__internal__getModuleExecutionResult(res.id));
+              if (res.error) {
+                reject(new Error(err));
+              } else {
+                resolve2(
+                  compiler.__internal__getModuleExecutionResult(res.id)
+                );
+              }
             }
           }
         );
@@ -6009,10 +6225,14 @@ async function runLoaders(compiler, context2) {
           if (res.cacheable === false) {
             this.cacheable(false);
           }
-          callback(
-            void 0,
-            compiler.__internal__getModuleExecutionResult(res.id)
-          );
+          if (res.error) {
+            callback(new Error(err), void 0);
+          } else {
+            callback(
+              void 0,
+              compiler.__internal__getModuleExecutionResult(res.id)
+            );
+          }
         }
       }
     );
@@ -6272,65 +6492,78 @@ async function runLoaders(compiler, context2) {
     enumerable: true,
     get: () => context2.__internal__parseMeta
   });
-  switch (loaderState) {
-    case import_binding23.JsLoaderState.Pitching: {
-      while (loaderContext.loaderIndex < loaderContext.loaders.length) {
-        const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
-        if (currentLoaderObject.shouldYield()) break;
-        if (currentLoaderObject.pitchExecuted) {
-          loaderContext.loaderIndex += 1;
-          continue;
-        }
-        await loadLoaderAsync(currentLoaderObject);
-        const fn2 = currentLoaderObject.pitch;
-        currentLoaderObject.pitchExecuted = true;
-        if (!fn2) continue;
-        const args = await runSyncOrAsync(fn2, loaderContext, [
-          loaderContext.remainingRequest,
-          loaderContext.previousRequest,
-          currentLoaderObject.data
-        ]) || [];
-        const hasArg = args.some((value) => value !== void 0);
-        if (hasArg) {
-          const [content, sourceMap, additionalData] = args;
-          context2.content = isNil(content) ? null : toBuffer(content);
-          context2.sourceMap = serializeObject(sourceMap);
-          context2.additionalData = additionalData;
-          break;
+  try {
+    switch (loaderState) {
+      case import_binding23.JsLoaderState.Pitching: {
+        while (loaderContext.loaderIndex < loaderContext.loaders.length) {
+          const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+          if (currentLoaderObject.shouldYield()) break;
+          if (currentLoaderObject.pitchExecuted) {
+            loaderContext.loaderIndex += 1;
+            continue;
+          }
+          await loadLoaderAsync(currentLoaderObject);
+          const fn2 = currentLoaderObject.pitch;
+          currentLoaderObject.pitchExecuted = true;
+          if (!fn2) continue;
+          const args = await runSyncOrAsync(fn2, loaderContext, [
+            loaderContext.remainingRequest,
+            loaderContext.previousRequest,
+            currentLoaderObject.data
+          ]) || [];
+          const hasArg = args.some((value) => value !== void 0);
+          if (hasArg) {
+            const [content, sourceMap, additionalData] = args;
+            context2.content = isNil(content) ? null : toBuffer(content);
+            context2.sourceMap = serializeObject(sourceMap);
+            context2.additionalData = additionalData;
+            break;
+          }
         }
+        break;
       }
-      break;
-    }
-    case import_binding23.JsLoaderState.Normal: {
-      let content = context2.content;
-      let sourceMap = JsSourceMap.__from_binding(context2.sourceMap);
-      let additionalData = context2.additionalData;
-      while (loaderContext.loaderIndex >= 0) {
-        const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
-        if (currentLoaderObject.shouldYield()) break;
-        if (currentLoaderObject.normalExecuted) {
-          loaderContext.loaderIndex--;
-          continue;
+      case import_binding23.JsLoaderState.Normal: {
+        let content = context2.content;
+        let sourceMap = JsSourceMap.__from_binding(context2.sourceMap);
+        let additionalData = context2.additionalData;
+        while (loaderContext.loaderIndex >= 0) {
+          const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+          if (currentLoaderObject.shouldYield()) break;
+          if (currentLoaderObject.normalExecuted) {
+            loaderContext.loaderIndex--;
+            continue;
+          }
+          await loadLoaderAsync(currentLoaderObject);
+          const fn2 = currentLoaderObject.normal;
+          currentLoaderObject.normalExecuted = true;
+          if (!fn2) continue;
+          const args = [content, sourceMap, additionalData];
+          convertArgs(args, !!currentLoaderObject.raw);
+          [content, sourceMap, additionalData] = await runSyncOrAsync(fn2, loaderContext, args) || [];
         }
-        await loadLoaderAsync(currentLoaderObject);
-        const fn2 = currentLoaderObject.normal;
-        currentLoaderObject.normalExecuted = true;
-        if (!fn2) continue;
-        const args = [content, sourceMap, additionalData];
-        convertArgs(args, !!currentLoaderObject.raw);
-        [content, sourceMap, additionalData] = await runSyncOrAsync(fn2, loaderContext, args) || [];
-      }
-      context2.content = isNil(content) ? null : toBuffer(content);
-      context2.sourceMap = JsSourceMap.__to_binding(sourceMap);
-      context2.additionalData = additionalData;
-      break;
+        context2.content = isNil(content) ? null : toBuffer(content);
+        context2.sourceMap = JsSourceMap.__to_binding(sourceMap);
+        context2.additionalData = additionalData;
+        break;
+      }
+      default:
+        throw new Error(`Unexpected loader runner state: ${loaderState}`);
     }
-    default:
-      throw new Error(`Unexpected loader runner state: ${loaderState}`);
+    context2.loaderItems = loaderContext.loaders.map(
+      (item) => LoaderObject.__to_binding(item)
+    );
+  } catch (e) {
+    const error = e;
+    context2.__internal__error = typeof e === "string" ? {
+      name: "ModuleBuildError",
+      message: e
+    } : {
+      name: "ModuleBuildError",
+      message: error.message,
+      stack: typeof error.stack === "string" ? error.stack : void 0,
+      hideStack: "hideStack" in error ? error.hideStack === true || error.hideStack === "true" : void 0
+    };
   }
-  context2.loaderItems = loaderContext.loaders.map(
-    (item) => LoaderObject.__to_binding(item)
-  );
   return context2;
 }
 function utf8BufferToString(buf) {
@@ -6755,7 +6988,7 @@ var getRawModuleRule = (rule, path10, options, upperType) => {
     parser: rule.parser ? getRawParserOptions(rule.parser, rule.type ?? upperType) : void 0,
     generator: rule.generator ? getRawGeneratorOptions(rule.generator, rule.type ?? upperType) : void 0,
     resolve: rule.resolve ? getRawResolve(rule.resolve) : void 0,
-    oneOf: rule.oneOf ? rule.oneOf.map(
+    oneOf: rule.oneOf ? rule.oneOf.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
         `${path10}.oneOf[${index}]`,
@@ -6763,7 +6996,7 @@ var getRawModuleRule = (rule, path10, options, upperType) => {
         rule2.type ?? upperType
       )
     ) : void 0,
-    rules: rule.rules ? rule.rules.map(
+    rules: rule.rules ? rule.rules.filter(Boolean).map(
       (rule2, index) => getRawModuleRule(
         rule2,
         `${path10}.rules[${index}]`,
@@ -6809,10 +7042,7 @@ function getRawRuleSetCondition(condition) {
   if (condition instanceof RegExp) {
     return {
       type: import_binding24.RawRuleSetConditionType.regexp,
-      regexp: {
-        source: condition.source,
-        flags: condition.flags
-      }
+      regexp: condition
     };
   }
   if (typeof condition === "function") {
@@ -8206,7 +8436,7 @@ var applyRspackOptionsDefaults = (options) => {
   D(options, "profile", false);
   D(options, "bail", false);
   F(options, "cache", () => development);
-  applyExperimentsDefaults(options.experiments);
+  applyExperimentsDefaults(options.experiments, { production });
   applySnapshotDefaults(options.snapshot, { production });
   applyModuleDefaults(options.module, {
     asyncWebAssembly: options.experiments.asyncWebAssembly,
@@ -8282,24 +8512,24 @@ var applyInfrastructureLoggingDefaults = (infrastructureLogging2) => {
   D(infrastructureLogging2, "colors", tty);
   D(infrastructureLogging2, "appendOnly", !tty);
 };
-var applyExperimentsDefaults = (experiments3) => {
+var applyExperimentsDefaults = (experiments3, { production }) => {
   D(experiments3, "futureDefaults", false);
   D(experiments3, "lazyCompilation", false);
   D(experiments3, "asyncWebAssembly", experiments3.futureDefaults);
   D(experiments3, "css", experiments3.futureDefaults ? true : void 0);
   D(experiments3, "layers", false);
   D(experiments3, "topLevelAwait", true);
-  D(experiments3, "incremental", {});
+  D(experiments3, "incremental", !production ? {} : false);
   if (typeof experiments3.incremental === "object") {
     D(experiments3.incremental, "make", true);
-    D(experiments3.incremental, "emitAssets", true);
     D(experiments3.incremental, "inferAsyncModules", false);
     D(experiments3.incremental, "providedExports", false);
     D(experiments3.incremental, "dependenciesDiagnostics", false);
+    D(experiments3.incremental, "buildChunkGraph", false);
     D(experiments3.incremental, "modulesHashes", false);
     D(experiments3.incremental, "modulesCodegen", false);
     D(experiments3.incremental, "modulesRuntimeRequirements", false);
-    D(experiments3.incremental, "buildChunkGraph", false);
+    D(experiments3.incremental, "emitAssets", true);
   }
   D(experiments3, "rspackFuture", {});
 };
@@ -9673,8 +9903,8 @@ var baseRuleSetRule = import_zod.z.strictObject({
   enforce: import_zod.z.literal("pre").or(import_zod.z.literal("post")).optional()
 });
 var ruleSetRule = baseRuleSetRule.extend({
-  oneOf: import_zod.z.lazy(() => ruleSetRule.array()).optional(),
-  rules: import_zod.z.lazy(() => ruleSetRule.array()).optional()
+  oneOf: import_zod.z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
+  rules: import_zod.z.lazy(() => ruleSetRule.or(falsy).array()).optional()
 });
 var ruleSetRules = import_zod.z.array(
   import_zod.z.literal("...").or(ruleSetRule).or(falsy)
@@ -9927,7 +10157,12 @@ var externalsType = import_zod.z.enum([
   "node-commonjs"
 ]);
 var externalItemValue = import_zod.z.string().or(import_zod.z.boolean()).or(import_zod.z.string().array().min(1)).or(
-  import_zod.z.record(import_zod.z.string().or(import_zod.z.string().array()))
+  import_zod.z.strictObject({
+    root: import_zod.z.string().or(import_zod.z.string().array()),
+    commonjs: import_zod.z.string().or(import_zod.z.string().array()),
+    commonjs2: import_zod.z.string().or(import_zod.z.string().array()),
+    amd: import_zod.z.string().or(import_zod.z.string().array()).optional()
+  })
 );
 var externalItemObjectUnknown = import_zod.z.record(
   externalItemValue
@@ -10523,11 +10758,39 @@ var FlagDependencyExportsPlugin = create2(
 
 // src/builtin-plugin/FlagDependencyUsagePlugin.ts
 var import_binding37 = require("@rspack/binding");
-var FlagDependencyUsagePlugin = create2(
-  import_binding37.BuiltinPluginName.FlagDependencyUsagePlugin,
-  (global) => global,
-  "compilation"
-);
+var FlagDependencyUsagePlugin = class extends RspackBuiltinPlugin {
+  constructor(global) {
+    super();
+    this.global = global;
+    this.name = import_binding37.BuiltinPluginName.FlagDependencyUsagePlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.FlagDependencyUsagePlugin"
+    );
+    if (incremental2.modulesHashes) {
+      incremental2.modulesHashes = false;
+      logger.warn(
+        "`optimization.usedExports` can't be used with `incremental.modulesHashes` as export usage is a global effect. `incremental.modulesHashes` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesCodegen) {
+      incremental2.modulesCodegen = false;
+      logger.warn(
+        "`optimization.usedExports` can't be used with `incremental.modulesCodegen` as export usage is a global effect. `incremental.modulesCodegen` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesRuntimeRequirements) {
+      incremental2.modulesRuntimeRequirements = false;
+      logger.warn(
+        "`optimization.usedExports` can't be used with `incremental.modulesRuntimeRequirements` as export usage is a global effect. `incremental.modulesRuntimeRequirements` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, this.global);
+  }
+};
 
 // src/builtin-plugin/HotModuleReplacementPlugin.ts
 var import_binding38 = require("@rspack/binding");
@@ -10551,7 +10814,8 @@ var import_binding39 = require("@rspack/binding");
 var liteTapable3 = __toESM(require("@rspack/lite-tapable"));
 var import_zod2 = require("../compiled/zod/index.js");
 
-// ../../node_modules/.pnpm/zod-validation-error@3.3.1_zod@3.23.8/node_modules/zod-validation-error/dist/index.mjs
+// ../../node_modules/.pnpm/zod-validation-error@3.4.0_zod@3.23.8/node_modules/zod-validation-error/dist/index.mjs
+var zod2 = __toESM(require("../compiled/zod/index.js"), 1);
 var zod = __toESM(require("../compiled/zod/index.js"), 1);
 function isZodErrorLike(err) {
   return err instanceof Error && err.name === "ZodError" && "issues" in err && Array.isArray(err.issues);
@@ -10577,22 +10841,8 @@ function getIssuesFromErrorOptions(options) {
   }
   return [];
 }
-var ISSUE_SEPARATOR = "; ";
-var MAX_ISSUES_IN_MESSAGE = 99;
-var PREFIX = "Validation error";
-var PREFIX_SEPARATOR = ": ";
-var UNION_SEPARATOR = ", or ";
-function prefixMessage(message, prefix, prefixSeparator) {
-  if (prefix !== null) {
-    if (message.length > 0) {
-      return [prefix, message].join(prefixSeparator);
-    }
-    return prefix;
-  }
-  if (message.length > 0) {
-    return message;
-  }
-  return PREFIX;
+function isNonEmptyArray(value) {
+  return value.length !== 0;
 }
 var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
 function joinPath(path10) {
@@ -10616,12 +10866,35 @@ function joinPath(path10) {
 function escapeQuotes(str) {
   return str.replace(/"/g, '\\"');
 }
-function isNonEmptyArray(value) {
-  return value.length !== 0;
+var ISSUE_SEPARATOR = "; ";
+var MAX_ISSUES_IN_MESSAGE = 99;
+var PREFIX = "Validation error";
+var PREFIX_SEPARATOR = ": ";
+var UNION_SEPARATOR = ", or ";
+function createMessageBuilder(props = {}) {
+  const {
+    issueSeparator = ISSUE_SEPARATOR,
+    unionSeparator = UNION_SEPARATOR,
+    prefixSeparator = PREFIX_SEPARATOR,
+    prefix = PREFIX,
+    includePath = true,
+    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE
+  } = props;
+  return (issues) => {
+    const message = issues.slice(0, maxIssuesInMessage).map(
+      (issue) => getMessageFromZodIssue({
+        issue,
+        issueSeparator,
+        unionSeparator,
+        includePath
+      })
+    ).join(issueSeparator);
+    return prefixMessage(message, prefix, prefixSeparator);
+  };
 }
 function getMessageFromZodIssue(props) {
   const { issue, issueSeparator, unionSeparator, includePath } = props;
-  if (issue.code === "invalid_union") {
+  if (issue.code === zod.ZodIssueCode.invalid_union) {
     return issue.unionErrors.reduce((acc, zodError) => {
       const newIssues = zodError.issues.map(
         (issue2) => getMessageFromZodIssue({
@@ -10637,7 +10910,7 @@ function getMessageFromZodIssue(props) {
       return acc;
     }, []).join(unionSeparator);
   }
-  if (issue.code === "invalid_arguments") {
+  if (issue.code === zod.ZodIssueCode.invalid_arguments) {
     return [
       issue.message,
       ...issue.argumentsError.issues.map(
@@ -10650,7 +10923,7 @@ function getMessageFromZodIssue(props) {
       )
     ].join(issueSeparator);
   }
-  if (issue.code === "invalid_return_type") {
+  if (issue.code === zod.ZodIssueCode.invalid_return_type) {
     return [
       issue.message,
       ...issue.returnTypeError.issues.map(
@@ -10674,6 +10947,18 @@ function getMessageFromZodIssue(props) {
   }
   return issue.message;
 }
+function prefixMessage(message, prefix, prefixSeparator) {
+  if (prefix !== null) {
+    if (message.length > 0) {
+      return [prefix, message].join(prefixSeparator);
+    }
+    return prefix;
+  }
+  if (message.length > 0) {
+    return message;
+  }
+  return PREFIX;
+}
 function fromZodError(zodError, options = {}) {
   if (!isZodErrorLike(zodError)) {
     throw new TypeError(
@@ -10683,26 +10968,22 @@ function fromZodError(zodError, options = {}) {
   return fromZodErrorWithoutRuntimeCheck(zodError, options);
 }
 function fromZodErrorWithoutRuntimeCheck(zodError, options = {}) {
-  const {
-    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE,
-    issueSeparator = ISSUE_SEPARATOR,
-    unionSeparator = UNION_SEPARATOR,
-    prefixSeparator = PREFIX_SEPARATOR,
-    prefix = PREFIX,
-    includePath = true
-  } = options;
   const zodIssues = zodError.errors;
-  const reason = zodIssues.length === 0 ? zodError.message : zodIssues.slice(0, maxIssuesInMessage).map(
-    (issue) => getMessageFromZodIssue({
-      issue,
-      issueSeparator,
-      unionSeparator,
-      includePath
-    })
-  ).join(issueSeparator);
-  const message = prefixMessage(reason, prefix, prefixSeparator);
+  let message;
+  if (isNonEmptyArray(zodIssues)) {
+    const messageBuilder = createMessageBuilderFromOptions2(options);
+    message = messageBuilder(zodIssues);
+  } else {
+    message = zodError.message;
+  }
   return new ValidationError(message, { cause: zodError });
 }
+function createMessageBuilderFromOptions2(options) {
+  if ("messageBuilder" in options) {
+    return options.messageBuilder;
+  }
+  return createMessageBuilder(options);
+}
 var toValidationError = (options = {}) => (err) => {
   if (isZodErrorLike(err)) {
     return fromZodErrorWithoutRuntimeCheck(err, options);
@@ -11330,11 +11611,39 @@ var LimitChunkCountPlugin = create2(
 
 // src/builtin-plugin/MangleExportsPlugin.ts
 var import_binding48 = require("@rspack/binding");
-var MangleExportsPlugin = create2(
-  import_binding48.BuiltinPluginName.MangleExportsPlugin,
-  (deterministic) => deterministic,
-  "compilation"
-);
+var MangleExportsPlugin = class extends RspackBuiltinPlugin {
+  constructor(deterministic) {
+    super();
+    this.deterministic = deterministic;
+    this.name = import_binding48.BuiltinPluginName.MangleExportsPlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.MangleExportsPlugin"
+    );
+    if (incremental2.modulesHashes) {
+      incremental2.modulesHashes = false;
+      logger.warn(
+        "`optimization.mangleExports` can't be used with `incremental.modulesHashes` as export mangling is a global effect. `incremental.modulesHashes` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesCodegen) {
+      incremental2.modulesCodegen = false;
+      logger.warn(
+        "`optimization.mangleExports` can't be used with `incremental.modulesCodegen` as export mangling is a global effect. `incremental.modulesCodegen` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesRuntimeRequirements) {
+      incremental2.modulesRuntimeRequirements = false;
+      logger.warn(
+        "`optimization.mangleExports` can't be used with `incremental.modulesRuntimeRequirements` as export mangling is a global effect. `incremental.modulesRuntimeRequirements` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, this.deterministic);
+  }
+};
 
 // src/builtin-plugin/MergeDuplicateChunksPlugin.ts
 var import_binding49 = require("@rspack/binding");
@@ -11354,12 +11663,38 @@ var ModuleChunkFormatPlugin = create2(
 
 // src/builtin-plugin/ModuleConcatenationPlugin.ts
 var import_binding51 = require("@rspack/binding");
-var ModuleConcatenationPlugin = create2(
-  import_binding51.BuiltinPluginName.ModuleConcatenationPlugin,
-  () => {
-  },
-  "compilation"
-);
+var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
+  constructor() {
+    super(...arguments);
+    this.name = import_binding51.BuiltinPluginName.ModuleConcatenationPlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.ModuleConcatenationPlugin"
+    );
+    if (incremental2.modulesHashes) {
+      incremental2.modulesHashes = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.modulesHashes` as module concatenation is a global effect. `incremental.modulesHashes` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesCodegen) {
+      incremental2.modulesCodegen = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.modulesCodegen` as module concatenation is a global effect. `incremental.modulesCodegen` has been overridden to false."
+      );
+    }
+    if (incremental2.modulesRuntimeRequirements) {
+      incremental2.modulesRuntimeRequirements = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.modulesRuntimeRequirements` as module concatenation is a global effect. `incremental.modulesRuntimeRequirements` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, void 0);
+  }
+};
 
 // src/builtin-plugin/NamedChunkIdsPlugin.ts
 var import_binding52 = require("@rspack/binding");
@@ -12524,6 +12859,7 @@ var checkVersion = () => {
 };
 
 // src/Compiler.ts
+var COMPILATION_WEAK_MAP = /* @__PURE__ */ new WeakMap();
 var Compiler = class _Compiler {
   #instance;
   #initial;
@@ -12990,8 +13326,12 @@ var Compiler = class _Compiler {
     });
   }
   #createCompilation(native) {
-    const compilation = new Compilation(this, native);
-    compilation.name = this.name;
+    let compilation = COMPILATION_WEAK_MAP.get(native);
+    if (!compilation) {
+      compilation = new Compilation(this, native);
+      compilation.name = this.name;
+      COMPILATION_WEAK_MAP.set(native, compilation);
+    }
     this.#compilation = compilation;
     return compilation;
   }
@@ -13036,9 +13376,7 @@ var Compiler = class _Compiler {
         binding2.RegisterJsTapKind.CompilerThisCompilation,
         () => this.hooks.thisCompilation,
         (queried) => (native) => {
-          if (this.#compilation === void 0) {
-            this.#createCompilation(native);
-          }
+          this.#createCompilation(native);
           queried.call(this.#compilation, this.#compilationParams);
         }
       ),
@@ -14775,6 +15113,7 @@ var MODULES_GROUPERS = (type) => ({
       groupModulesByAttributes,
       groupModulesByType,
       groupModulesByPath,
+      groupModulesByLayer,
       groupModulesByExtension
     } = options;
     if (groupModulesByAttributes) {
@@ -14827,6 +15166,20 @@ var MODULES_GROUPERS = (type) => ({
         }
       });
     }
+    if (groupModulesByLayer) {
+      groupConfigs.push({
+        getKeys: (module2) => (
+          /** @type {string[]} */
+          [module2.layer]
+        ),
+        createGroup: (key, children, _modules) => ({
+          type: "modules by layer",
+          layer: key,
+          children,
+          ...moduleGroup(children)
+        })
+      });
+    }
     if (groupModulesByPath || groupModulesByExtension) {
       groupConfigs.push({
         getKeys: (module2) => {
@@ -17305,10 +17658,7 @@ var RspackOptionsApply = class {
         typeof lazyOptions.test === "function" ? (jsModule) => lazyOptions.test.call(
           lazyOptions,
           new Module(jsModule)
-        ) : lazyOptions.test ? {
-          source: lazyOptions.test.source,
-          flags: lazyOptions.test.flags
-        } : void 0,
+        ) : lazyOptions.test,
         lazyOptions.backend
       ).apply(compiler);
     }