@rspack/core 1.1.4 → 1.1.6

package/dist/index.js

@@ -742,7 +742,7 @@ __export(src_exports, {
   rspackVersion: () => rspackVersion,
   sharing: () => sharing,
   sources: () => sources,
-  util: () => util6,
+  util: () => util7,
   version: () => version,
   wasm: () => wasm,
   web: () => web,
@@ -804,7 +804,7 @@ __export(exports_exports, {
   rspackVersion: () => rspackVersion,
   sharing: () => sharing,
   sources: () => sources,
-  util: () => util6,
+  util: () => util7,
   version: () => version,
   wasm: () => wasm,
   web: () => web,
@@ -1716,10 +1716,11 @@ RuntimeModule.STAGE_TRIGGER = 20 /* TRIGGER */;
 // src/Stats.ts
 var Stats = class {
   #inner;
+  #compilation;
   #innerMap;
   constructor(compilation) {
     this.#inner = compilation.__internal_getInner().getStats();
-    this.compilation = compilation;
+    this.#compilation = compilation;
     this.#innerMap = new WeakMap([[this.compilation, this.#inner]]);
   }
   // use correct JsStats for child compilation
@@ -1731,6 +1732,14 @@ var Stats = class {
     this.#innerMap.set(compilation, inner);
     return inner;
   }
+  get compilation() {
+    if (this.#compilation.__internal__shutdown) {
+      throw new Error(
+        "Unable to access `Stats` after the compiler was shutdown"
+      );
+    }
+    return this.#compilation;
+  }
   get hash() {
     return this.compilation.hash;
   }
@@ -2662,24 +2671,20 @@ var JsAssetInfo = class {
 
 // src/util/MergeCaller.ts
 var MergeCaller = class {
-  constructor(fn2, debounceTime) {
-    this.timer = null;
+  constructor(fn2) {
     this.callArgs = [];
     this.finalCall = () => {
-      this.timer = null;
       const args = this.callArgs;
       this.callArgs = [];
       this.callFn(args);
     };
-    this.debounceTime = debounceTime;
     this.callFn = fn2;
   }
   push(...data) {
-    if (this.timer) {
-      clearTimeout(this.timer);
+    if (this.callArgs.length === 0) {
+      queueMicrotask(this.finalCall);
     }
     this.callArgs.push(...data);
-    this.timer = setTimeout(this.finalCall, this.debounceTime);
   }
 };
 
@@ -2712,7 +2717,7 @@ function createReadonlyMap(obj) {
 
 // src/util/fake.ts
 function createFakeCompilationDependencies(getDeps, addDeps) {
-  const addDepsCaller = new MergeCaller(addDeps, 10);
+  const addDepsCaller = new MergeCaller(addDeps);
   return {
     *[Symbol.iterator]() {
       const deps = getDeps();
@@ -2787,11 +2792,12 @@ function memoizeValue(fn2) {
 }
 
 // src/Compilation.ts
-var _inner, _customModules, _Compilation_instances, createCachedAssets_fn, _rebuildModuleCaller;
+var _inner, _shutdown, _customModules, _Compilation_instances, createCachedAssets_fn, _rebuildModuleCaller;
 var _Compilation = class _Compilation {
   constructor(compiler, inner) {
     __privateAdd(this, _Compilation_instances);
     __privateAdd(this, _inner);
+    __privateAdd(this, _shutdown);
     this.fileSystemInfo = {
       createSnapshot() {
         return null;
@@ -2833,10 +2839,10 @@ var _Compilation = class _Compilation {
             }
           }
         );
-      },
-      10
+      }
     ))(this));
     __privateSet(this, _inner, inner);
+    __privateSet(this, _shutdown, false);
     __privateSet(this, _customModules, {});
     const processAssetsHook = new liteTapable.AsyncSeriesHook([
       "assets"
@@ -3574,12 +3580,19 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
   __internal_getInner() {
     return __privateGet(this, _inner);
   }
+  get __internal__shutdown() {
+    return __privateGet(this, _shutdown);
+  }
+  set __internal__shutdown(shutdown) {
+    __privateSet(this, _shutdown, shutdown);
+  }
   seal() {
   }
   unseal() {
   }
 };
 _inner = new WeakMap();
+_shutdown = new WeakMap();
 _customModules = new WeakMap();
 _Compilation_instances = new WeakSet();
 createCachedAssets_fn = function() {
@@ -5402,12 +5415,26 @@ var DeterministicChunkIdsPlugin = create2(
 
 // src/builtin-plugin/DeterministicModuleIdsPlugin.ts
 var import_binding21 = require("@rspack/binding");
-var DeterministicModuleIdsPlugin = create2(
-  import_binding21.BuiltinPluginName.DeterministicModuleIdsPlugin,
-  () => {
-  },
-  "compilation"
-);
+var DeterministicModuleIdsPlugin = class extends RspackBuiltinPlugin {
+  constructor() {
+    super(...arguments);
+    this.name = import_binding21.BuiltinPluginName.DeterministicModuleIdsPlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.DeterministicModuleIdsPlugin"
+    );
+    if (incremental2.moduleIds) {
+      incremental2.moduleIds = false;
+      logger.warn(
+        "`optimization.moduleIds = 'deterministic'` can't be used with `incremental.moduleIds` as deterministic module ids is a global effect. `incremental.moduleIds` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, void 0);
+  }
+};
 
 // src/builtin-plugin/DynamicEntryPlugin.ts
 var import_binding25 = require("@rspack/binding");
@@ -6231,7 +6258,7 @@ async function runLoaders(compiler, context2) {
                 this.cacheable(false);
               }
               if (res.error) {
-                reject(new Error(err));
+                reject(new Error(res.error));
               } else {
                 resolve2(
                   compiler.__internal__getModuleExecutionResult(res.id)
@@ -6770,6 +6797,7 @@ var getRawOptions = (options, compiler) => {
     node: getRawNode(options.node),
     // SAFETY: applied default value in `applyRspackOptionsDefaults`.
     profile: options.profile,
+    amd: options.amd,
     // SAFETY: applied default value in `applyRspackOptionsDefaults`.
     bail: options.bail,
     __references: {}
@@ -6851,7 +6879,6 @@ function getRawOutput(output2) {
     crossOriginLoading: getRawCrossOriginLoading(output2.crossOriginLoading),
     cssFilename: output2.cssFilename,
     cssChunkFilename: output2.cssChunkFilename,
-    cssHeadDataCompression: output2.cssHeadDataCompression,
     hotUpdateChunkFilename: output2.hotUpdateChunkFilename,
     hotUpdateMainFilename: output2.hotUpdateMainFilename,
     hotUpdateGlobal: output2.hotUpdateGlobal,
@@ -7378,6 +7405,8 @@ function getRawIncremental(incremental2) {
     providedExports: incremental2.providedExports,
     dependenciesDiagnostics: incremental2.dependenciesDiagnostics,
     buildChunkGraph: incremental2.buildChunkGraph,
+    moduleIds: incremental2.moduleIds,
+    chunkIds: incremental2.chunkIds,
     modulesHashes: incremental2.modulesHashes,
     modulesCodegen: incremental2.modulesCodegen,
     modulesRuntimeRequirements: incremental2.modulesRuntimeRequirements,
@@ -8593,6 +8622,8 @@ var applyExperimentsDefaults = (experiments3, { production }) => {
     D(experiments3.incremental, "providedExports", false);
     D(experiments3.incremental, "dependenciesDiagnostics", false);
     D(experiments3.incremental, "buildChunkGraph", false);
+    D(experiments3.incremental, "moduleIds", false);
+    D(experiments3.incremental, "chunkIds", false);
     D(experiments3.incremental, "modulesHashes", false);
     D(experiments3.incremental, "modulesCodegen", false);
     D(experiments3.incremental, "modulesRuntimeRequirements", false);
@@ -8903,7 +8934,6 @@ while determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
   const uniqueNameId = Template.toIdentifier(output2.uniqueName);
   F(output2, "hotUpdateGlobal", () => `webpackHotUpdate${uniqueNameId}`);
   F(output2, "chunkLoadingGlobal", () => `webpackChunk${uniqueNameId}`);
-  D(output2, "cssHeadDataCompression", !development);
   D(output2, "assetModuleFilename", "[hash][ext][query]");
   D(output2, "webassemblyModuleFilename", "[hash].module.wasm");
   D(output2, "compareBeforeEmit", true);
@@ -9026,6 +9056,7 @@ ${helpMessage}`
       "policyName",
       () => output2.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
     );
+    D(trustedTypes2, "onPolicyCreationFailure", "stop");
   }
   const forEachEntry = (fn2) => {
     if (typeof entry2 === "function") {
@@ -9375,6 +9406,7 @@ var A = (obj, prop, factory) => {
 };
 
 // src/config/normalization.ts
+var import_node_util4 = __toESM(require("util"));
 var getNormalizedRspackOptions = (config2) => {
   return {
     ignoreWarnings: config2.ignoreWarnings !== void 0 ? config2.ignoreWarnings.map((ignore) => {
@@ -9391,6 +9423,13 @@ var getNormalizedRspackOptions = (config2) => {
     mode: config2.mode,
     entry: config2.entry === void 0 ? { main: {} } : typeof config2.entry === "function" ? /* @__PURE__ */ ((fn2) => () => Promise.resolve().then(fn2).then(getNormalizedEntryStatic))(config2.entry) : getNormalizedEntryStatic(config2.entry),
     output: nestedConfig(config2.output, (output2) => {
+      if ("cssHeadDataCompression" in output2) {
+        import_node_util4.default.deprecate(
+          () => {
+          },
+          "cssHeadDataCompression is not used now, see https://github.com/web-infra-dev/rspack/pull/8534, this option could be removed in the future"
+        )();
+      }
       const { library: library3 } = output2;
       const libraryAsName = library3;
       const libraryBase = typeof library3 === "object" && library3 && !Array.isArray(library3) && "type" in library3 ? library3 : libraryAsName || output2.libraryTarget ? {
@@ -9406,7 +9445,6 @@ var getNormalizedRspackOptions = (config2) => {
         chunkLoading: output2.chunkLoading,
         chunkFilename: output2.chunkFilename,
         crossOriginLoading: output2.crossOriginLoading,
-        cssHeadDataCompression: output2.cssHeadDataCompression,
         cssFilename: output2.cssFilename,
         cssChunkFilename: output2.cssChunkFilename,
         hotUpdateMainFilename: output2.hotUpdateMainFilename,
@@ -9557,6 +9595,8 @@ var getNormalizedRspackOptions = (config2) => {
           inferAsyncModules: true,
           providedExports: true,
           buildChunkGraph: true,
+          moduleIds: true,
+          chunkIds: true,
           modulesHashes: true,
           modulesCodegen: true,
           modulesRuntimeRequirements: true,
@@ -9571,6 +9611,7 @@ var getNormalizedRspackOptions = (config2) => {
     watchOptions: cloneObject(config2.watchOptions),
     devServer: config2.devServer,
     profile: config2.profile,
+    amd: config2.amd ? JSON.stringify(config2.amd) : void 0,
     bail: config2.bail
   };
 };
@@ -9938,7 +9979,12 @@ var chunkLoadingGlobal = import_zod2.z.string();
 var enabledLibraryTypes = import_zod2.z.array(
   libraryType
 );
-var clean = import_zod2.z.boolean();
+var clean = import_zod2.z.union([
+  import_zod2.z.boolean(),
+  import_zod2.z.strictObject({
+    keep: import_zod2.z.string().optional()
+  })
+]);
 var outputModule = import_zod2.z.boolean();
 var strictModuleExceptionHandling = import_zod2.z.boolean();
 var strictModuleErrorHandling = import_zod2.z.boolean();
@@ -9955,7 +10001,8 @@ var enabledChunkLoadingTypes = import_zod2.z.array(
 var chunkFormat = import_zod2.z.literal(false).or(import_zod2.z.string());
 var workerPublicPath = import_zod2.z.string();
 var trustedTypes = import_zod2.z.strictObject({
-  policyName: import_zod2.z.string().optional()
+  policyName: import_zod2.z.string().optional(),
+  onPolicyCreationFailure: import_zod2.z.enum(["continue", "stop"]).optional()
 });
 var hashDigest = import_zod2.z.string();
 var hashDigestLength = import_zod2.z.number();
@@ -10428,8 +10475,18 @@ var externalItemFunctionData = import_zod2.z.strictObject({
   dependencyType: import_zod2.z.string().optional(),
   request: import_zod2.z.string().optional(),
   contextInfo: import_zod2.z.strictObject({
-    issuer: import_zod2.z.string()
-  }).optional()
+    issuer: import_zod2.z.string(),
+    issuerLayer: import_zod2.z.string().or(import_zod2.z.null()).optional()
+  }).optional(),
+  getResolve: import_zod2.z.function().returns(
+    import_zod2.z.function().args(import_zod2.z.string(), import_zod2.z.string()).returns(import_zod2.z.promise(import_zod2.z.string())).or(
+      import_zod2.z.function().args(
+        import_zod2.z.string(),
+        import_zod2.z.string(),
+        import_zod2.z.function().args(import_zod2.z.instanceof(Error).optional(), import_zod2.z.string().optional()).returns(import_zod2.z.void())
+      ).returns(import_zod2.z.void())
+    )
+  ).optional()
 });
 var externalItem = import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(externalItemObjectUnknown).or(
   import_zod2.z.function().args(
@@ -10733,6 +10790,8 @@ var incremental = import_zod2.z.strictObject({
   providedExports: import_zod2.z.boolean().optional(),
   dependenciesDiagnostics: import_zod2.z.boolean().optional(),
   buildChunkGraph: import_zod2.z.boolean().optional(),
+  moduleIds: import_zod2.z.boolean().optional(),
+  chunkIds: import_zod2.z.boolean().optional(),
   modulesHashes: import_zod2.z.boolean().optional(),
   modulesCodegen: import_zod2.z.boolean().optional(),
   modulesRuntimeRequirements: import_zod2.z.boolean().optional(),
@@ -10766,6 +10825,7 @@ var ignoreWarnings = import_zod2.z.instanceof(RegExp).or(
   import_zod2.z.function().args(import_zod2.z.instanceof(Error), import_zod2.z.custom()).returns(import_zod2.z.boolean())
 ).array();
 var profile = import_zod2.z.boolean();
+var amd = import_zod2.z.literal(false).or(import_zod2.z.record(import_zod2.z.any()));
 var bail = import_zod2.z.boolean();
 var performance = import_zod2.z.strictObject({
   assetFilter: import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean()).optional(),
@@ -10802,6 +10862,7 @@ var rspackOptions = import_zod2.z.strictObject({
   devServer: devServer.optional(),
   module: moduleOptions.optional(),
   profile: profile.optional(),
+  amd: amd.optional(),
   bail: bail.optional(),
   performance: performance.optional()
 });
@@ -10960,29 +11021,126 @@ var EvalSourceMapDevToolPlugin = create2(
 
 // src/builtin-plugin/ExternalsPlugin.ts
 var import_binding33 = require("@rspack/binding");
-var ExternalsPlugin = create2(
-  import_binding33.BuiltinPluginName.ExternalsPlugin,
-  (type, externals2) => {
-    return {
+
+// src/Resolver.ts
+function isString(value) {
+  return typeof value === "string";
+}
+var Resolver = class _Resolver {
+  constructor(binding3) {
+    this.binding = binding3;
+  }
+  resolveSync(context2, path10, request) {
+    return this.binding.resolveSync(path10, request);
+  }
+  resolve(context2, path10, request, resolveContext, callback) {
+    try {
+      const res = this.binding.resolveSync(path10, request);
+      callback(null, res);
+    } catch (err) {
+      callback(err);
+    }
+  }
+  withOptions({
+    dependencyCategory,
+    resolveToContext,
+    ...resolve2
+  }) {
+    const rawResolve = getRawResolve(resolve2);
+    if (Array.isArray(rawResolve.restrictions)) {
+      rawResolve.restrictions = rawResolve.restrictions.filter(isString);
+    }
+    const binding3 = this.binding.withOptions({
+      dependencyCategory,
+      resolveToContext,
+      ...rawResolve
+    });
+    return new _Resolver(binding3);
+  }
+};
+
+// src/builtin-plugin/ExternalsPlugin.ts
+var ExternalsPlugin = class extends RspackBuiltinPlugin {
+  constructor(type, externals2) {
+    super();
+    this.type = type;
+    this.externals = externals2;
+    this.name = import_binding33.BuiltinPluginName.ExternalsPlugin;
+  }
+  raw(compiler) {
+    const { type, externals: externals2 } = this;
+    const raw = {
       type,
-      externals: (Array.isArray(externals2) ? externals2 : [externals2]).filter(Boolean).map(getRawExternalItem)
+      externals: (Array.isArray(externals2) ? externals2 : [externals2]).filter(Boolean).map((item) => getRawExternalItem(compiler, item))
     };
+    return createBuiltinPlugin(this.name, raw);
   }
-);
-function getRawExternalItem(item) {
+};
+function getRawExternalItem(compiler, item) {
   if (typeof item === "string" || item instanceof RegExp) {
     return item;
   }
   if (typeof item === "function") {
     return async (ctx) => {
       return await new Promise((resolve2, reject) => {
-        const promise = item(ctx, (err, result2, type) => {
-          if (err) reject(err);
-          resolve2({
-            result: getRawExternalItemValueFormFnResult(result2),
-            externalType: type
-          });
-        });
+        const data = ctx.data();
+        const promise = item(
+          {
+            request: data.request,
+            dependencyType: data.dependencyType,
+            context: data.context,
+            contextInfo: {
+              issuer: data.contextInfo.issuer,
+              issuerLayer: data.contextInfo.issuerLayer ?? null
+            },
+            getResolve: function getResolve(options) {
+              const resolver = new Resolver(ctx.getResolver());
+              const getResolveContext = () => ({
+                fileDependencies: compiler._lastCompilation.fileDependencies,
+                missingDependencies: compiler._lastCompilation.missingDependencies,
+                contextDependencies: compiler._lastCompilation.contextDependencies
+              });
+              const child = options ? resolver.withOptions(options) : resolver;
+              return (context2, request, callback) => {
+                if (callback) {
+                  child.resolve(
+                    {},
+                    context2,
+                    request,
+                    getResolveContext(),
+                    (err, result2) => {
+                      if (err) return callback(err);
+                      callback(
+                        void 0,
+                        typeof result2 === "string" ? result2 : void 0
+                      );
+                    }
+                  );
+                } else {
+                  return new Promise((resolve3, reject2) => {
+                    child.resolve(
+                      {},
+                      context2,
+                      request,
+                      getResolveContext(),
+                      (err, result2) => {
+                        if (err) reject2(err);
+                        else resolve3(result2);
+                      }
+                    );
+                  });
+                }
+              };
+            }
+          },
+          (err, result2, type) => {
+            if (err) reject(err);
+            resolve2({
+              result: getRawExternalItemValueFormFnResult(result2),
+              externalType: type
+            });
+          }
+        );
         if (promise == null ? void 0 : promise.then) {
           promise.then(
             (result2) => resolve2({
@@ -11367,6 +11525,7 @@ var htmlRspackPluginOptions = import_zod3.z.strictObject({
   scriptLoading: import_zod3.z.enum(["blocking", "defer", "module", "systemjs-module"]).optional(),
   chunks: import_zod3.z.string().array().optional(),
   excludeChunks: import_zod3.z.string().array().optional(),
+  chunksSortMode: import_zod3.z.enum(["auto", "manual"]).optional(),
   sri: import_zod3.z.enum(["sha256", "sha384", "sha512"]).optional(),
   minify: import_zod3.z.boolean().optional(),
   title: import_zod3.z.string().optional(),
@@ -11397,6 +11556,7 @@ var HtmlRspackPluginImpl = create2(
     const configInject = c.inject ?? true;
     const inject = configInject === true ? scriptLoading === "blocking" ? "body" : "head" : configInject === false ? "false" : configInject;
     const base = typeof c.base === "string" ? { href: c.base } : c.base;
+    const chunksSortMode = c.chunksSortMode ?? "auto";
     let compilation = null;
     this.hooks.compilation.tap("HtmlRspackPlugin", (compilationInstance) => {
       compilation = compilationInstance;
@@ -11525,6 +11685,7 @@ var HtmlRspackPluginImpl = create2(
       publicPath: c.publicPath,
       chunks: c.chunks,
       excludeChunks: c.excludeChunks,
+      chunksSortMode,
       sri: c.sri,
       minify: c.minify,
       meta,
@@ -11950,6 +12111,12 @@ var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
     const logger = compiler.getInfrastructureLogger(
       "rspack.ModuleConcatenationPlugin"
     );
+    if (incremental2.moduleIds) {
+      incremental2.moduleIds = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.moduleIds` as module concatenation is a global effect. `incremental.moduleIds` has been overridden to false."
+      );
+    }
     if (incremental2.modulesHashes) {
       incremental2.modulesHashes = false;
       logger.warn(
@@ -11968,6 +12135,24 @@ var ModuleConcatenationPlugin = class extends RspackBuiltinPlugin {
         "`optimization.concatenateModules` can't be used with `incremental.modulesRuntimeRequirements` as module concatenation is a global effect. `incremental.modulesRuntimeRequirements` has been overridden to false."
       );
     }
+    if (incremental2.chunksRuntimeRequirements) {
+      incremental2.chunksRuntimeRequirements = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.chunksRuntimeRequirements` as module concatenation is a global effect. `incremental.chunksRuntimeRequirements` has been overridden to false."
+      );
+    }
+    if (incremental2.chunksHashes) {
+      incremental2.chunksHashes = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.chunksHashes` as module concatenation is a global effect. `incremental.chunksHashes` has been overridden to false."
+      );
+    }
+    if (incremental2.chunksRender) {
+      incremental2.chunksRender = false;
+      logger.warn(
+        "`optimization.concatenateModules` can't be used with `incremental.chunksRender` as module concatenation is a global effect. `incremental.chunksRender` has been overridden to false."
+      );
+    }
     return createBuiltinPlugin(this.name, void 0);
   }
 };
@@ -12001,12 +12186,26 @@ var NaturalChunkIdsPlugin = create2(
 
 // src/builtin-plugin/NaturalModuleIdsPlugin.ts
 var import_binding54 = require("@rspack/binding");
-var NaturalModuleIdsPlugin = create2(
-  import_binding54.BuiltinPluginName.NaturalModuleIdsPlugin,
-  () => {
-  },
-  "compilation"
-);
+var NaturalModuleIdsPlugin = class extends RspackBuiltinPlugin {
+  constructor() {
+    super(...arguments);
+    this.name = import_binding54.BuiltinPluginName.NaturalModuleIdsPlugin;
+    this.affectedHooks = "compilation";
+  }
+  raw(compiler) {
+    const incremental2 = compiler.options.experiments.incremental;
+    const logger = compiler.getInfrastructureLogger(
+      "rspack.NaturalModuleIdsPlugin"
+    );
+    if (incremental2.moduleIds) {
+      incremental2.moduleIds = false;
+      logger.warn(
+        "`optimization.moduleIds = 'natural'` can't be used with `incremental.moduleIds` as natural module ids is a global effect. `incremental.moduleIds` has been overridden to false."
+      );
+    }
+    return createBuiltinPlugin(this.name, void 0);
+  }
+};
 
 // src/builtin-plugin/NodeTargetPlugin.ts
 var import_binding55 = require("@rspack/binding");
@@ -12043,7 +12242,8 @@ var ProvidePlugin = create2(
       return [key, value];
     });
     return Object.fromEntries(entries);
-  }
+  },
+  "compilation"
 );
 
 // src/builtin-plugin/RealContentHashPlugin.ts
@@ -12500,7 +12700,7 @@ var ContextModuleFactory = class {
 };
 
 // src/FileSystem.ts
-var import_node_util4 = __toESM(require("util"));
+var import_node_util5 = __toESM(require("util"));
 
 // src/util/fs.ts
 var import_node_assert6 = __toESM(require("assert"));
@@ -12610,6 +12810,7 @@ var mkdirp = (fs5, p, callback) => {
 };
 
 // src/FileSystem.ts
+var BUFFER_SIZE = 1e3;
 var NOOP_FILESYSTEM = {
   writeFile() {
   },
@@ -12628,29 +12829,45 @@ var NOOP_FILESYSTEM = {
   stat: () => {
   },
   lstat: () => {
+  },
+  open: () => {
+  },
+  rename: () => {
+  },
+  close: () => {
+  },
+  write: () => {
+  },
+  writeAll: () => {
+  },
+  read: () => {
+  },
+  readUntil: () => {
+  },
+  readToEnd: () => {
   }
 };
-var ThreadsafeWritableNodeFS = class _ThreadsafeWritableNodeFS {
+var ThreadsafeOutputNodeFS = class _ThreadsafeOutputNodeFS {
   constructor(fs5) {
+    Object.assign(this, NOOP_FILESYSTEM);
     if (!fs5) {
-      Object.assign(this, NOOP_FILESYSTEM);
       return;
     }
-    this.writeFile = memoizeFn(() => import_node_util4.default.promisify(fs5.writeFile.bind(fs5)));
-    this.removeFile = memoizeFn(() => import_node_util4.default.promisify(fs5.unlink.bind(fs5)));
-    this.mkdir = memoizeFn(() => import_node_util4.default.promisify(fs5.mkdir.bind(fs5)));
-    this.mkdirp = memoizeFn(() => import_node_util4.default.promisify(mkdirp.bind(null, fs5)));
-    this.removeDirAll = memoizeFn(() => import_node_util4.default.promisify(rmrf.bind(null, fs5)));
+    this.writeFile = memoizeFn(() => import_node_util5.default.promisify(fs5.writeFile.bind(fs5)));
+    this.removeFile = memoizeFn(() => import_node_util5.default.promisify(fs5.unlink.bind(fs5)));
+    this.mkdir = memoizeFn(() => import_node_util5.default.promisify(fs5.mkdir.bind(fs5)));
+    this.mkdirp = memoizeFn(() => import_node_util5.default.promisify(mkdirp.bind(null, fs5)));
+    this.removeDirAll = memoizeFn(() => import_node_util5.default.promisify(rmrf.bind(null, fs5)));
     this.readDir = memoizeFn(() => {
-      const readDirFn = import_node_util4.default.promisify(fs5.readdir.bind(fs5));
+      const readDirFn = import_node_util5.default.promisify(fs5.readdir.bind(fs5));
       return async (filePath) => {
         const res = await readDirFn(filePath);
         return res;
       };
     });
-    this.readFile = memoizeFn(() => import_node_util4.default.promisify(fs5.readFile.bind(fs5)));
+    this.readFile = memoizeFn(() => import_node_util5.default.promisify(fs5.readFile.bind(fs5)));
     this.stat = memoizeFn(() => {
-      const statFn = import_node_util4.default.promisify(fs5.stat.bind(fs5));
+      const statFn = import_node_util5.default.promisify(fs5.stat.bind(fs5));
       return async (filePath) => {
         const res = await statFn(filePath);
         return res && {
@@ -12665,10 +12882,10 @@ var ThreadsafeWritableNodeFS = class _ThreadsafeWritableNodeFS {
       };
     });
     this.lstat = memoizeFn(() => {
-      const statFn = import_node_util4.default.promisify((fs5.lstat || fs5.stat).bind(fs5));
+      const statFn = import_node_util5.default.promisify((fs5.lstat || fs5.stat).bind(fs5));
       return async (filePath) => {
         const res = await statFn(filePath);
-        return res && _ThreadsafeWritableNodeFS.__to_binding_stat(res);
+        return res && _ThreadsafeOutputNodeFS.__to_binding_stat(res);
       };
     });
   }
@@ -12687,6 +12904,90 @@ var ThreadsafeWritableNodeFS = class _ThreadsafeWritableNodeFS {
     };
   }
 };
+var ThreadsafeIntermediateNodeFS = class extends ThreadsafeOutputNodeFS {
+  constructor(fs5) {
+    super(fs5);
+    if (!fs5) {
+      return;
+    }
+    this.open = memoizeFn(() => import_node_util5.default.promisify(fs5.open.bind(fs5)));
+    this.rename = memoizeFn(() => import_node_util5.default.promisify(fs5.rename.bind(fs5)));
+    this.close = memoizeFn(() => import_node_util5.default.promisify(fs5.close.bind(fs5)));
+    this.write = memoizeFn(() => {
+      const writeFn = import_node_util5.default.promisify(fs5.write.bind(fs5));
+      return async (fd, content, position) => {
+        return await writeFn(fd, content, {
+          position
+        });
+      };
+    });
+    this.writeAll = memoizeFn(() => {
+      const writeFn = import_node_util5.default.promisify(fs5.writeFile.bind(fs5));
+      return async (fd, content) => {
+        return await writeFn(fd, content);
+      };
+    });
+    this.read = memoizeFn(() => {
+      const readFn = fs5.read.bind(fs5);
+      return async (fd, length, position) => {
+        new Promise((resolve2) => {
+          readFn(
+            fd,
+            {
+              position,
+              length
+            },
+            (err, bytesRead, buffer) => {
+              if (err) {
+                resolve2(err);
+              } else {
+                resolve2(buffer);
+              }
+            }
+          );
+        });
+      };
+    });
+    this.readUntil = memoizeFn(() => {
+      return async (fd, delim, position) => {
+        const res = [];
+        let current_position = position;
+        while (true) {
+          const buffer = await this.read(fd, BUFFER_SIZE, current_position);
+          if (!buffer || buffer.length === 0) {
+            break;
+          }
+          const pos = buffer.indexOf(delim);
+          if (pos >= 0) {
+            res.push(buffer.slice(0, pos));
+            break;
+          }
+          res.push(buffer);
+          current_position += buffer.length;
+        }
+        return Buffer.concat(res);
+      };
+    });
+    this.readToEnd = memoizeFn(() => {
+      return async (fd, position) => {
+        const res = [];
+        let current_position = position;
+        while (true) {
+          const buffer = await this.read(fd, BUFFER_SIZE, current_position);
+          if (!buffer || buffer.length === 0) {
+            break;
+          }
+          res.push(buffer);
+          current_position += buffer.length;
+        }
+        return Buffer.concat(res);
+      };
+    });
+  }
+  static __to_binding(fs5) {
+    return new this(fs5);
+  }
+};
 
 // src/NormalModuleFactory.ts
 var liteTapable6 = __toESM(require("@rspack/lite-tapable"));
@@ -12710,45 +13011,6 @@ var NormalModuleFactory = class {
 
 // src/ResolverFactory.ts
 var binding = __toESM(require("@rspack/binding"));
-
-// src/Resolver.ts
-function isString(value) {
-  return typeof value === "string";
-}
-var Resolver = class _Resolver {
-  constructor(binding3) {
-    this.binding = binding3;
-  }
-  resolveSync(context2, path10, request) {
-    return this.binding.resolveSync(path10, request);
-  }
-  resolve(context2, path10, request, resolveContext, callback) {
-    try {
-      const res = this.binding.resolveSync(path10, request);
-      callback(null, res);
-    } catch (err) {
-      callback(err);
-    }
-  }
-  withOptions({
-    dependencyCategory,
-    resolveToContext,
-    ...resolve2
-  }) {
-    const rawResolve = getRawResolve(resolve2);
-    if (Array.isArray(rawResolve.restrictions)) {
-      rawResolve.restrictions = rawResolve.restrictions.filter(isString);
-    }
-    const binding3 = this.binding.withOptions({
-      dependencyCategory,
-      resolveToContext,
-      ...rawResolve
-    });
-    return new _Resolver(binding3);
-  }
-};
-
-// src/ResolverFactory.ts
 var ResolverFactory = class {
   #binding;
   static __to_binding(resolver_factory) {
@@ -13211,7 +13473,10 @@ var Compiler = class _Compiler {
     new ExecuteModulePlugin().apply(this);
     this.hooks.shutdown.tap("rspack:cleanup", () => {
       if (!this.running) {
-        this.#instance = void 0;
+        process.nextTick(() => {
+          this.#instance = void 0;
+          this.#compilation && (this.#compilation.__internal__shutdown = true);
+        });
       }
     });
   }
@@ -13652,11 +13917,9 @@ var Compiler = class _Compiler {
     this.#registers = {
       registerCompilerThisCompilationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerThisCompilation,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.thisCompilation;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function(native) {
             that.deref().#createCompilation(native);
@@ -13669,11 +13932,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilerCompilationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerCompilation,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.compilation;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function() {
             return queried.call(
@@ -13685,11 +13946,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilerMakeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerMake,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.make;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(that.deref().#compilation);
@@ -13698,11 +13957,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilerFinishMakeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerFinishMake,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.finishMake;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(that.deref().#compilation);
@@ -13711,11 +13968,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilerShouldEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerShouldEmit,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.shouldEmit;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function() {
             return queried.call(that.deref().#compilation);
@@ -13724,11 +13979,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilerEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerEmit,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.emit;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(that.deref().#compilation);
@@ -13737,11 +13990,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilerAfterEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerAfterEmit,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.afterEmit;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(that.deref().#compilation);
@@ -13750,11 +14001,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilerAssetEmittedTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerAssetEmitted,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().hooks.assetEmitted;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function({
             filename: filename2,
@@ -13779,11 +14028,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationAdditionalTreeRuntimeRequirements: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAdditionalTreeRuntimeRequirements,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.additionalTreeRuntimeRequirements;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function({
             chunk,
@@ -13802,11 +14049,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationRuntimeRequirementInTree: this.#createHookMapRegisterTaps(
         binding2.RegisterJsTapKind.CompilationRuntimeRequirementInTree,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.runtimeRequirementInTree;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function({
             chunk: rawChunk,
@@ -13828,11 +14073,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationRuntimeModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationRuntimeModule,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.runtimeModule;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function({ module: module2, chunk }) {
             var _a, _b;
@@ -13851,11 +14094,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationBuildModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationBuildModule,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.buildModule;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function(m) {
             return queried.call(
@@ -13866,11 +14107,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationStillValidModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationStillValidModule,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.stillValidModule;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function(m) {
             return queried.call(
@@ -13881,11 +14120,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationSucceedModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationSucceedModule,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.succeedModule;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function(m) {
             return queried.call(
@@ -13896,11 +14133,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationExecuteModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationExecuteModule,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.executeModule;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function({
             entry: entry2,
@@ -13961,11 +14196,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationFinishModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationFinishModules,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.finishModules;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(that.deref().#compilation.modules);
@@ -13974,11 +14207,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationOptimizeModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeModules,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.optimizeModules;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function() {
             return queried.call(that.deref().#compilation.modules.values());
@@ -13987,11 +14218,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationAfterOptimizeModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterOptimizeModules,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.afterOptimizeModules;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function() {
             queried.call(that.deref().#compilation.modules.values());
@@ -14000,11 +14229,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationOptimizeTreeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeTree,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.optimizeTree;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(
@@ -14016,11 +14243,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationOptimizeChunkModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeChunkModules,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.optimizeChunkModules;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(
@@ -14032,11 +14257,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationChunkHashTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationChunkHash,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.chunkHash;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function(chunk) {
             if (!that.deref().options.output.hashFunction) {
@@ -14056,11 +14279,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationChunkAssetTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationChunkAsset,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.chunkAsset;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function({ chunk, filename: filename2 }) {
             return queried.call(
@@ -14072,11 +14293,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationProcessAssetsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationProcessAssets,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.processAssets;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise(that.deref().#compilation.assets);
@@ -14085,11 +14304,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationAfterProcessAssetsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterProcessAssets,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.afterProcessAssets;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function() {
             return queried.call(that.deref().#compilation.assets);
@@ -14098,11 +14315,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationSealTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationSeal,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.seal;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function() {
             return queried.call();
@@ -14111,11 +14326,9 @@ var Compiler = class _Compiler {
       ),
       registerCompilationAfterSealTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterSeal,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilation.hooks.afterSeal;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function() {
             return await queried.promise();
@@ -14124,11 +14337,9 @@ var Compiler = class _Compiler {
       ),
       registerNormalModuleFactoryBeforeResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryBeforeResolve,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.normalModuleFactory.hooks.beforeResolve;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(resolveData) {
             const normalizedResolveData = {
@@ -14150,11 +14361,9 @@ var Compiler = class _Compiler {
       ),
       registerNormalModuleFactoryFactorizeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryFactorize,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.normalModuleFactory.hooks.factorize;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(resolveData) {
             const normalizedResolveData = {
@@ -14176,11 +14385,9 @@ var Compiler = class _Compiler {
       ),
       registerNormalModuleFactoryResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryResolve,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.normalModuleFactory.hooks.resolve;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(resolveData) {
             const normalizedResolveData = {
@@ -14202,11 +14409,9 @@ var Compiler = class _Compiler {
       ),
       registerNormalModuleFactoryResolveForSchemeTaps: this.#createHookMapRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryResolveForScheme,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.normalModuleFactory.hooks.resolveForScheme;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(args) {
             const ret = await queried.for(args.scheme).promise(args.resourceData);
@@ -14216,11 +14421,9 @@ var Compiler = class _Compiler {
       ),
       registerNormalModuleFactoryAfterResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryAfterResolve,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.normalModuleFactory.hooks.afterResolve;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(arg) {
             const data = {
@@ -14241,11 +14444,9 @@ var Compiler = class _Compiler {
       ),
       registerNormalModuleFactoryCreateModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryCreateModule,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.normalModuleFactory.hooks.createModule;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(args) {
             const data = {
@@ -14258,11 +14459,9 @@ var Compiler = class _Compiler {
       ),
       registerContextModuleFactoryBeforeResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.ContextModuleFactoryBeforeResolve,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.contextModuleFactory.hooks.beforeResolve;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(bindingData) {
             const data = bindingData ? ContextModuleFactoryBeforeResolveData.__from_binding(
@@ -14275,11 +14474,9 @@ var Compiler = class _Compiler {
       ),
       registerContextModuleFactoryAfterResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.ContextModuleFactoryAfterResolve,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return that.deref().#compilationParams.contextModuleFactory.hooks.afterResolve;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(bindingData) {
             const data = bindingData ? ContextModuleFactoryAfterResolveData.__from_binding(
@@ -14292,13 +14489,11 @@ var Compiler = class _Compiler {
       ),
       registerJavascriptModulesChunkHashTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.JavascriptModulesChunkHash,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return JavascriptModulesPlugin.getCompilationHooks(
             that.deref().#compilation
           ).chunkHash;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return function(chunk) {
             if (!that.deref().options.output.hashFunction) {
@@ -14318,13 +14513,11 @@ var Compiler = class _Compiler {
       ),
       registerHtmlPluginBeforeAssetTagGenerationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginBeforeAssetTagGeneration,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return HtmlRspackPlugin.getCompilationHooks(
             that.deref().#compilation
           ).beforeAssetTagGeneration;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(data) {
             return await queried.promise({
@@ -14340,13 +14533,11 @@ var Compiler = class _Compiler {
       ),
       registerHtmlPluginAlterAssetTagsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAlterAssetTags,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return HtmlRspackPlugin.getCompilationHooks(
             that.deref().#compilation
           ).alterAssetTags;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(data) {
             return await queried.promise(data);
@@ -14355,13 +14546,11 @@ var Compiler = class _Compiler {
       ),
       registerHtmlPluginAlterAssetTagGroupsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAlterAssetTagGroups,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return HtmlRspackPlugin.getCompilationHooks(
             that.deref().#compilation
           ).alterAssetTagGroups;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(data) {
             return await queried.promise({
@@ -14377,13 +14566,11 @@ var Compiler = class _Compiler {
       ),
       registerHtmlPluginAfterTemplateExecutionTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAfterTemplateExecution,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return HtmlRspackPlugin.getCompilationHooks(
             that.deref().#compilation
           ).afterTemplateExecution;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(data) {
             return await queried.promise({
@@ -14399,13 +14586,11 @@ var Compiler = class _Compiler {
       ),
       registerHtmlPluginBeforeEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginBeforeEmit,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return HtmlRspackPlugin.getCompilationHooks(
             that.deref().#compilation
           ).beforeEmit;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(data) {
             return await queried.promise({
@@ -14421,13 +14606,11 @@ var Compiler = class _Compiler {
       ),
       registerHtmlPluginAfterEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAfterEmit,
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function() {
           return HtmlRspackPlugin.getCompilationHooks(
             that.deref().#compilation
           ).afterEmit;
         },
-        // biome-ignore lint/complexity/useArrowFunction: <explanation>
         function(queried) {
           return async function(data) {
             return await queried.promise({
@@ -14446,7 +14629,8 @@ var Compiler = class _Compiler {
       rawOptions,
       this.#builtinPlugins,
       this.#registers,
-      ThreadsafeWritableNodeFS.__to_binding(this.outputFileSystem),
+      ThreadsafeOutputNodeFS.__to_binding(this.outputFileSystem),
+      ThreadsafeIntermediateNodeFS.__to_binding(this.intermediateFileSystem),
       ResolverFactory.__to_binding(this.resolverFactory)
     );
     callback(null, this.#instance);
@@ -15266,7 +15450,7 @@ _MemoryCachePlugin.PLUGIN_NAME = "MemoryCachePlugin";
 var MemoryCachePlugin = _MemoryCachePlugin;
 
 // src/stats/DefaultStatsFactoryPlugin.ts
-var util3 = __toESM(require("util"));
+var util4 = __toESM(require("util"));
 
 // src/stats/statsFactoryUtils.ts
 var iterateConfig = (config2, options, fn2) => {
@@ -16131,7 +16315,7 @@ var SIMPLE_EXTRACTORS = {
               if (depthInCollapsedGroup > 0) depthInCollapsedGroup--;
               continue;
             }
-            const message = entry2.args && entry2.args.length > 0 ? util3.format(entry2.args[0], ...entry2.args.slice(1)) : "";
+            const message = entry2.args && entry2.args.length > 0 ? util4.format(entry2.args[0], ...entry2.args.slice(1)) : "";
             const newEntry = {
               type,
               message,
@@ -18920,7 +19104,7 @@ var createConsoleLogger = ({
 };
 
 // src/node/NodeWatchFileSystem.ts
-var import_node_util5 = __toESM(require("util"));
+var import_node_util6 = __toESM(require("util"));
 var import_watchpack = __toESM(require("../compiled/watchpack/index.js"));
 var NodeWatchFileSystem = class {
   constructor(inputFileSystem) {
@@ -19005,7 +19189,7 @@ var NodeWatchFileSystem = class {
           this.watcher.pause();
         }
       },
-      getAggregatedRemovals: import_node_util5.default.deprecate(
+      getAggregatedRemovals: import_node_util6.default.deprecate(
         () => {
           var _a, _b, _c;
           const items = (_a = this.watcher) == null ? void 0 : _a.aggregatedRemovals;
@@ -19020,7 +19204,7 @@ var NodeWatchFileSystem = class {
         "Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.",
         "DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"
       ),
-      getAggregatedChanges: import_node_util5.default.deprecate(
+      getAggregatedChanges: import_node_util6.default.deprecate(
         () => {
           var _a, _b, _c;
           const items = (_a = this.watcher) == null ? void 0 : _a.aggregatedChanges;
@@ -19035,14 +19219,14 @@ var NodeWatchFileSystem = class {
         "Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.",
         "DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES"
       ),
-      getFileTimeInfoEntries: import_node_util5.default.deprecate(
+      getFileTimeInfoEntries: import_node_util6.default.deprecate(
         () => {
           return fetchTimeInfo().fileTimeInfoEntries;
         },
         "Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
         "DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES"
       ),
-      getContextTimeInfoEntries: import_node_util5.default.deprecate(
+      getContextTimeInfoEntries: import_node_util6.default.deprecate(
         () => {
           return fetchTimeInfo().contextTimeInfoEntries;
         },
@@ -19079,7 +19263,7 @@ var NodeWatchFileSystem = class {
 };
 
 // src/node/nodeConsole.ts
-var util5 = __toESM(require("util"));
+var util6 = __toESM(require("util"));
 
 // src/logging/truncateArgs.ts
 var arraySum = (array) => {
@@ -19179,7 +19363,7 @@ ${prefix}`);
       if (currentCollapsed > 0) return;
       clearStatusMessage();
       const str = indent3(
-        util5.format(...args),
+        util6.format(...args),
         prefix,
         colorPrefix,
         colorSuffix
@@ -19854,7 +20038,7 @@ var config = {
   getNormalizedWebpackOptions: getNormalizedRspackOptions,
   applyWebpackOptionsDefaults: applyRspackOptionsDefaults
 };
-var util6 = { createHash, cleverMerge: cachedCleverMerge };
+var util7 = { createHash, cleverMerge: cachedCleverMerge };
 var web = {
   FetchCompileAsyncWasmPlugin
 };
@@ -19897,7 +20081,7 @@ var experiments2 = {
 
 // src/rspack.ts
 var import_node_assert9 = __toESM(require("assert"));
-var import_node_util6 = __toESM(require("util"));
+var import_node_util7 = __toESM(require("util"));
 function createMultiCompiler(options) {
   const compilers = options.map(createCompiler);
   const compiler = new MultiCompiler(
@@ -19985,7 +20169,7 @@ function rspack2(options, callback) {
   } else {
     const { compiler, watch: watch2 } = create3();
     if (watch2) {
-      import_node_util6.default.deprecate(
+      import_node_util7.default.deprecate(
         () => {
         },
         "A 'callback' argument needs to be provided to the 'rspack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback."