@rsbuild/core 1.3.0-beta.1 → 1.3.0-beta.3

package/dist/index.cjs

@@ -995,7 +995,7 @@ __webpack_require__.n = (module)=>{
         enumerable: !0,
         get: definition[key]
     });
-}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = function(exports1) {
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports1)=>{
     'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
         value: 'Module'
     }), Object.defineProperty(exports1, '__esModule', {
@@ -1367,12 +1367,6 @@ var __webpack_exports__ = {};
         } catch  {
             return !1;
         }
-    }, parseUrl = (url)=>{
-        try {
-            return new external_node_url_namespaceObject.URL(url);
-        } catch  {
-            return null;
-        }
     }, ensureAssetPrefix = (url, assetPrefix = DEFAULT_ASSET_PREFIX)=>url.startsWith('//') || canParse(url) || 'auto' === assetPrefix || 'function' == typeof assetPrefix ? url : assetPrefix.startsWith('http') ? urlJoin(assetPrefix, url) : assetPrefix.startsWith('//') ? urlJoin(`https:${assetPrefix}`, url).replace('https:', '') : external_node_path_namespaceObject.posix.join(assetPrefix, url);
     function getFilename(config, type, isProd, isServer) {
         let { filename, filenameHash } = config.output, hash = 'string' == typeof filenameHash ? filenameHash ? `.[${filenameHash}]` : '' : filenameHash ? '.[contenthash:8]' : '';
@@ -2222,7 +2216,7 @@ var __webpack_exports__ = {};
     async function createContext(options, userConfig) {
         let { cwd } = options, rootPath = userConfig.root ? getAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, external_node_path_namespaceObject.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
         return {
-            version: "1.3.0-beta.1",
+            version: "1.3.0-beta.3",
             rootPath,
             distPath: '',
             cachePath,
@@ -2389,12 +2383,16 @@ var __webpack_exports__ = {};
             TS: 'ts',
             CSS: 'css',
             CSS_RAW: 'css-raw',
+            CSS_INLINE: 'css-inline',
             LESS: 'less',
             LESS_RAW: 'less-raw',
+            LESS_INLINE: 'less-inline',
             SASS: 'sass',
             SASS_RAW: 'sass-raw',
+            SASS_INLINE: 'sass-inline',
             STYLUS: 'stylus',
             STYLUS_RAW: 'stylus-raw',
+            STYLUS_INLINE: 'stylus-inline',
             SVG: 'svg',
             PUG: 'pug',
             VUE: 'vue',
@@ -2457,7 +2455,7 @@ var __webpack_exports__ = {};
         let generatorOptions = {
             filename
         };
-        !1 === emit && (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(/(__inline=false|url)/).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(/inline/), rule.oneOf(`${assetType}-asset`).type('asset').parser({
+        !1 === emit && (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(/(__inline=false|url)/).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(/inline/), rule.oneOf(`${assetType}-asset-raw`).type('asset/source').resourceQuery(/raw/), rule.oneOf(`${assetType}-asset`).type('asset').parser({
             dataUrlCondition: {
                 maxSize
             }
@@ -2527,10 +2525,8 @@ var __webpack_exports__ = {};
                             test: /\.css$/,
                             filename: '[file].map[query]'
                         }
-                    ]), chain.context(api.context.rootPath), chain.mode(environment.config.mode), chain.merge({
-                        infrastructureLogging: {
-                            level: 'error'
-                        }
+                    ]), chain.context(api.context.rootPath), chain.mode(environment.config.mode), chain.infrastructureLogging({
+                        level: 'error'
                     }), chain.watchOptions({
                         ignored: /[\\/](?:\.git|node_modules)[\\/]/,
                         aggregateTimeout: 0
@@ -2719,11 +2715,78 @@ var __webpack_exports__ = {};
         plugin && (pluginHelper_htmlPlugin = plugin);
     }, getHTMLPlugin = ()=>(pluginHelper_htmlPlugin || (pluginHelper_htmlPlugin = pluginHelper_require('../compiled/html-rspack-plugin/index.js')), pluginHelper_htmlPlugin), setCssExtractPlugin = (plugin)=>{
         cssExtractPlugin = plugin;
-    }, getCssExtractPlugin = ()=>cssExtractPlugin || core_default().CssExtractRspackPlugin, getCSSModulesLocalIdentName = (config, isProd)=>config.output.cssModules.localIdentName || (isProd ? '[local]-[hash:base64:6]' : '[path][name]__[local]-[hash:base64:6]'), getLightningCSSLoaderOptions = (config, targets)=>{
+    }, getCssExtractPlugin = ()=>cssExtractPlugin || core_default().CssExtractRspackPlugin, getSwcMinimizerOptions = (config, jsOptions)=>{
+        let options = {};
+        options.minimizerOptions ||= {}, options.minimizerOptions.format ||= {};
+        let { removeConsole } = config.performance;
+        if (!0 === removeConsole) options.minimizerOptions.compress = {
+            drop_console: !0
+        };
+        else if (Array.isArray(removeConsole)) {
+            let pureFuncs = removeConsole.map((method)=>`console.${method}`);
+            options.minimizerOptions.compress = {
+                pure_funcs: pureFuncs
+            };
+        }
+        switch(config.output.legalComments){
+            case 'inline':
+                options.minimizerOptions.format.comments = 'some', options.extractComments = !1;
+                break;
+            case 'linked':
+                options.extractComments = !0;
+                break;
+            case 'none':
+                options.minimizerOptions.format.comments = !1, options.extractComments = !1;
+        }
+        return (options.minimizerOptions.format.asciiOnly = 'ascii' === config.output.charset, jsOptions) ? cjs_default()(options, jsOptions) : options;
+    }, parseMinifyOptions = (config, isProd)=>{
+        let { minify } = config.output;
+        return !1 !== minify && isProd ? !0 === minify ? {
+            minifyJs: !0,
+            minifyCss: !0
+        } : {
+            minifyJs: !1 !== minify.js,
+            minifyCss: !1 !== minify.css,
+            jsOptions: minify.jsOptions,
+            cssOptions: minify.cssOptions
+        } : {
+            minifyJs: !1,
+            minifyCss: !1
+        };
+    }, pluginMinimize = ()=>({
+            name: 'rsbuild:minimize',
+            setup (api) {
+                let isRspack = 'rspack' === api.context.bundlerType;
+                api.modifyBundlerChain(async (chain, { isProd, environment, CHAIN_ID })=>{
+                    let { config } = environment, { minifyJs, minifyCss, jsOptions, cssOptions } = parseMinifyOptions(config, isProd);
+                    if (chain.optimization.minimize(minifyJs || minifyCss), minifyJs && isRspack && chain.optimization.minimizer(CHAIN_ID.MINIMIZER.JS).use(core_namespaceObject.rspack.SwcJsMinimizerRspackPlugin, [
+                        getSwcMinimizerOptions(config, jsOptions)
+                    ]).end(), minifyCss && isRspack) {
+                        let loaderOptions = getLightningCSSLoaderOptions(config, environment.browserslist, !0), defaultOptions = {
+                            minimizerOptions: {
+                                targets: isPlainObject(loaderOptions.targets) ? environment.browserslist : loaderOptions.targets,
+                                ...pick(loaderOptions, [
+                                    'draft',
+                                    'include',
+                                    'exclude',
+                                    'nonStandard',
+                                    'pseudoClasses',
+                                    'unusedSymbols',
+                                    'errorRecovery'
+                                ])
+                            }
+                        }, mergedOptions = cssOptions ? cjs_default()(defaultOptions, cssOptions) : defaultOptions;
+                        chain.optimization.minimizer(CHAIN_ID.MINIMIZER.CSS).use(core_namespaceObject.rspack.LightningCssMinimizerRspackPlugin, [
+                            mergedOptions
+                        ]).end();
+                    }
+                });
+            }
+        }), getCSSModulesLocalIdentName = (config, isProd)=>config.output.cssModules.localIdentName || (isProd ? '[local]-[hash:base64:6]' : '[path][name]__[local]-[hash:base64:6]'), getLightningCSSLoaderOptions = (config, targets, minify)=>{
         let userOptions = 'object' == typeof config.tools.lightningcssLoader ? config.tools.lightningcssLoader : {}, initialOptions = {
             targets
         };
-        return 'production' === config.mode && config.output.injectStyles && (initialOptions.minify = !0), reduceConfigs({
+        return minify && (initialOptions.minify = !0), reduceConfigs({
             initial: initialOptions,
             config: userOptions
         });
@@ -2821,12 +2884,12 @@ var __webpack_exports__ = {};
                 api.modifyBundlerChain({
                     order: 'pre',
                     handler: async (chain, { target, isProd, CHAIN_ID, environment })=>{
-                        let rule = chain.module.rule(CHAIN_ID.RULE.CSS), { config } = environment;
+                        let rule = chain.module.rule(CHAIN_ID.RULE.CSS), inlineRule = chain.module.rule(CHAIN_ID.RULE.CSS_INLINE), { config } = environment;
                         rule.test(CSS_REGEX).type("javascript/auto").dependency({
                             not: 'url'
                         }).resourceQuery({
-                            not: /raw/
-                        }), chain.module.rule(CHAIN_ID.RULE.CSS_RAW).test(CSS_REGEX).type('asset/source').resourceQuery(/raw/);
+                            not: /raw|inline/
+                        }), inlineRule.test(CSS_REGEX).type("javascript/auto").resourceQuery(/inline/), chain.module.rule(CHAIN_ID.RULE.CSS_RAW).test(CSS_REGEX).type('asset/source').resourceQuery(/raw/);
                         let emitCss = config.output.emitCss ?? 'web' === target;
                         if (emitCss) {
                             if (config.output.injectStyles) {
@@ -2837,20 +2900,33 @@ var __webpack_exports__ = {};
                                 rule.use(CHAIN_ID.USE.STYLE).loader(getCompiledPath('style-loader')).options(styleLoaderOptions);
                             } else rule.use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader(getCssExtractPlugin().loader).options(config.tools.cssExtract.loaderOptions);
                         } else rule.use(CHAIN_ID.USE.IGNORE_CSS).loader(external_node_path_default().join(LOADER_PATH, 'ignoreCssLoader.mjs'));
-                        let importLoaders = 0;
-                        if (rule.use(CHAIN_ID.USE.CSS).loader(getCompiledPath('css-loader')), emitCss) {
+                        let importLoaders = 0, updateRules = (callback)=>{
+                            callback(rule, 'normal'), callback(inlineRule, 'inline');
+                        }, cssLoaderPath = getCompiledPath('css-loader');
+                        if (updateRules((rule)=>{
+                            rule.use(CHAIN_ID.USE.CSS).loader(cssLoaderPath);
+                        }), emitCss) {
                             var _postcssLoaderOptions_postcssOptions_plugins, _postcssLoaderOptions_postcssOptions;
                             if ('rspack' === api.context.bundlerType && !1 !== config.tools.lightningcssLoader) {
                                 importLoaders++;
-                                let lightningcssOptions = getLightningCSSLoaderOptions(config, environment.browserslist);
-                                rule.use(CHAIN_ID.USE.LIGHTNINGCSS).loader('builtin:lightningcss-loader').options(lightningcssOptions);
+                                let { minifyCss } = parseMinifyOptions(config, isProd);
+                                updateRules((rule, type)=>{
+                                    let minify = ('inline' === type || config.output.injectStyles) && isProd && minifyCss, lightningcssOptions = getLightningCSSLoaderOptions(config, environment.browserslist, minify);
+                                    rule.use(CHAIN_ID.USE.LIGHTNINGCSS).loader('builtin:lightningcss-loader').options(lightningcssOptions);
+                                });
                             }
                             let postcssLoaderOptions = await getPostcssLoaderOptions({
                                 config,
                                 root: api.context.rootPath,
                                 postcssrcCache
                             });
-                            ('function' == typeof postcssLoaderOptions.postcssOptions || (null === (_postcssLoaderOptions_postcssOptions = postcssLoaderOptions.postcssOptions) || void 0 === _postcssLoaderOptions_postcssOptions ? void 0 : null === (_postcssLoaderOptions_postcssOptions_plugins = _postcssLoaderOptions_postcssOptions.plugins) || void 0 === _postcssLoaderOptions_postcssOptions_plugins ? void 0 : _postcssLoaderOptions_postcssOptions_plugins.length)) && (importLoaders++, rule.use(CHAIN_ID.USE.POSTCSS).loader(getCompiledPath('postcss-loader')).options(postcssLoaderOptions));
+                            if ('function' == typeof postcssLoaderOptions.postcssOptions || (null === (_postcssLoaderOptions_postcssOptions = postcssLoaderOptions.postcssOptions) || void 0 === _postcssLoaderOptions_postcssOptions ? void 0 : null === (_postcssLoaderOptions_postcssOptions_plugins = _postcssLoaderOptions_postcssOptions.plugins) || void 0 === _postcssLoaderOptions_postcssOptions_plugins ? void 0 : _postcssLoaderOptions_postcssOptions_plugins.length)) {
+                                importLoaders++;
+                                let postcssLoaderPath = getCompiledPath('postcss-loader');
+                                updateRules((rule)=>{
+                                    rule.use(CHAIN_ID.USE.POSTCSS).loader(postcssLoaderPath).options(postcssLoaderOptions);
+                                });
+                            }
                         }
                         let localIdentName = getCSSModulesLocalIdentName(config, isProd), cssLoaderOptions = getCSSLoaderOptions({
                             config,
@@ -2858,11 +2934,15 @@ var __webpack_exports__ = {};
                             localIdentName,
                             emitCss
                         });
-                        rule.use(CHAIN_ID.USE.CSS).options(cssLoaderOptions);
+                        updateRules((rule, type)=>{
+                            rule.use(CHAIN_ID.USE.CSS).options('inline' === type ? {
+                                ...cssLoaderOptions,
+                                exportType: 'string',
+                                modules: !1
+                            } : cssLoaderOptions), rule.sideEffects(!0), rule.resolve.preferRelative(!0);
+                        });
                         let isStringExport = 'string' === cssLoaderOptions.exportType;
-                        if (isStringExport && rule.uses.has(CHAIN_ID.USE.MINI_CSS_EXTRACT) && rule.uses.delete(CHAIN_ID.USE.MINI_CSS_EXTRACT), rule.merge({
-                            sideEffects: !0
-                        }), rule.resolve.preferRelative(!0), emitCss && !config.output.injectStyles && !isStringExport) {
+                        if (isStringExport && rule.uses.has(CHAIN_ID.USE.MINI_CSS_EXTRACT) && rule.uses.delete(CHAIN_ID.USE.MINI_CSS_EXTRACT), emitCss && !config.output.injectStyles && !isStringExport) {
                             let extractPluginOptions = config.tools.cssExtract.pluginOptions, cssPath = config.output.distPath.css, cssFilename = getFilename(config, 'css', isProd), isCssFilenameFn = 'function' == typeof cssFilename, cssAsyncPath = config.output.distPath.cssAsync ?? (cssPath ? `${cssPath}/async` : 'async');
                             chain.plugin(CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT).use(getCssExtractPlugin(), [
                                 {
@@ -3446,19 +3526,6 @@ var __webpack_exports__ = {};
                     };
                 });
             }
-        }), pluginLazyCompilation = ()=>({
-            name: 'rsbuild:lazy-compilation',
-            setup (api) {
-                api.modifyBundlerChain((chain, { environment, isProd, target })=>{
-                    var _config_dev;
-                    if (isProd || 'web' !== target) return;
-                    let { config } = environment, options = null === (_config_dev = config.dev) || void 0 === _config_dev ? void 0 : _config_dev.lazyCompilation;
-                    options && chain.experiments({
-                        ...chain.get('experiments'),
-                        lazyCompilation: options
-                    });
-                });
-            }
         });
     function isAsync(chunk) {
         return 'canBeInitial' in chunk ? !chunk.canBeInitial() : 'isInitial' in chunk && !chunk.isInitial();
@@ -3552,73 +3619,6 @@ var __webpack_exports__ = {};
                     ]);
                 });
             }
-        }), getSwcMinimizerOptions = (config, jsOptions)=>{
-        let options = {};
-        options.minimizerOptions ||= {}, options.minimizerOptions.format ||= {};
-        let { removeConsole } = config.performance;
-        if (!0 === removeConsole) options.minimizerOptions.compress = {
-            drop_console: !0
-        };
-        else if (Array.isArray(removeConsole)) {
-            let pureFuncs = removeConsole.map((method)=>`console.${method}`);
-            options.minimizerOptions.compress = {
-                pure_funcs: pureFuncs
-            };
-        }
-        switch(config.output.legalComments){
-            case 'inline':
-                options.minimizerOptions.format.comments = 'some', options.extractComments = !1;
-                break;
-            case 'linked':
-                options.extractComments = !0;
-                break;
-            case 'none':
-                options.minimizerOptions.format.comments = !1, options.extractComments = !1;
-        }
-        return (options.minimizerOptions.format.asciiOnly = 'ascii' === config.output.charset, jsOptions) ? cjs_default()(options, jsOptions) : options;
-    }, parseMinifyOptions = (config, isProd)=>{
-        let { minify } = config.output;
-        return !1 !== minify && isProd ? !0 === minify ? {
-            minifyJs: !0,
-            minifyCss: !0
-        } : {
-            minifyJs: !1 !== minify.js,
-            minifyCss: !1 !== minify.css,
-            jsOptions: minify.jsOptions,
-            cssOptions: minify.cssOptions
-        } : {
-            minifyJs: !1,
-            minifyCss: !1
-        };
-    }, pluginMinimize = ()=>({
-            name: 'rsbuild:minimize',
-            setup (api) {
-                let isRspack = 'rspack' === api.context.bundlerType;
-                api.modifyBundlerChain(async (chain, { isProd, environment, CHAIN_ID })=>{
-                    let { config } = environment, { minifyJs, minifyCss, jsOptions, cssOptions } = parseMinifyOptions(config, isProd);
-                    if (chain.optimization.minimize(minifyJs || minifyCss), minifyJs && isRspack && chain.optimization.minimizer(CHAIN_ID.MINIMIZER.JS).use(core_namespaceObject.rspack.SwcJsMinimizerRspackPlugin, [
-                        getSwcMinimizerOptions(config, jsOptions)
-                    ]).end(), minifyCss && isRspack) {
-                        let loaderOptions = getLightningCSSLoaderOptions(config, environment.browserslist), defaultOptions = {
-                            minimizerOptions: {
-                                targets: isPlainObject(loaderOptions.targets) ? environment.browserslist : loaderOptions.targets,
-                                ...pick(loaderOptions, [
-                                    'draft',
-                                    'include',
-                                    'exclude',
-                                    'nonStandard',
-                                    'pseudoClasses',
-                                    'unusedSymbols',
-                                    'errorRecovery'
-                                ])
-                            }
-                        }, mergedOptions = cssOptions ? cjs_default()(defaultOptions, cssOptions) : defaultOptions;
-                        chain.optimization.minimizer(CHAIN_ID.MINIMIZER.CSS).use(core_namespaceObject.rspack.LightningCssMinimizerRspackPlugin, [
-                            mergedOptions
-                        ]).end();
-                    }
-                });
-            }
         });
     class PatchSplitChunksPlugin {
         apply(compiler) {
@@ -4045,17 +4045,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         let { config, tsconfigPath } = environment;
                         chain.resolve.extensions.merge([
                             ...config.resolve.extensions
-                        ]), tsconfigPath && !tsconfigPath.endsWith('jsconfig.json') && chain.resolve.extensionAlias.merge({
-                            '.js': [
-                                '.js',
-                                '.ts',
-                                '.tsx'
-                            ],
-                            '.jsx': [
-                                '.jsx',
-                                '.tsx'
-                            ]
-                        }), function({ chain, config, rootPath }) {
+                        ]), tsconfigPath && !tsconfigPath.endsWith('jsconfig.json') && chain.resolve.extensionAlias.set('.js', [
+                            '.js',
+                            '.ts',
+                            '.tsx'
+                        ]).set('.jsx', [
+                            '.jsx',
+                            '.tsx'
+                        ]), function({ chain, config, rootPath }) {
                             let mergedAlias = reduceConfigs({
                                 initial: {},
                                 config: config.resolve.alias
@@ -4679,11 +4676,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         asyncWebAssembly: !0
                     });
                     let wasmFilename = external_node_path_namespaceObject.posix.join(distPath, '[hash].module.wasm');
-                    chain.output.merge({
-                        webassemblyModuleFilename: wasmFilename
-                    }), chain.module.rule(CHAIN_ID.RULE.WASM).test(/\.wasm$/).merge({
-                        dependency: 'url'
-                    }).type('asset/resource').set('generator', {
+                    chain.output.webassemblyModuleFilename(wasmFilename), chain.module.rule(CHAIN_ID.RULE.WASM).test(/\.wasm$/).dependency('url').type('asset/resource').set('generator', {
                         filename: wasmFilename
                     });
                 });
@@ -5004,14 +4997,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }
     }
     async function setupWatchFiles(options) {
-        let { dev, server, root, compileMiddlewareAPI } = options, { hmr, liveReload } = dev;
-        if (!hmr && !liveReload || !compileMiddlewareAPI) return;
-        let closeDevFilesWatcher = await watchDevFiles(dev, compileMiddlewareAPI, root), serverFilesWatcher = await function(serverConfig, compileMiddlewareAPI, root) {
+        let { dev, server, root, compilationManager } = options, { hmr, liveReload } = dev;
+        if (!hmr && !liveReload || !compilationManager) return;
+        let closeDevFilesWatcher = await watchDevFiles(dev, compilationManager, root), serverFilesWatcher = await function(serverConfig, compilationManager, root) {
             let publicDirs = normalizePublicDirs(serverConfig.publicDir);
             if (!publicDirs.length) return;
             let watchPaths = publicDirs.filter((item)=>item.watch).map((item)=>item.name);
-            if (watchPaths.length) return startWatchFiles(prepareWatchOptions(watchPaths), compileMiddlewareAPI, root);
-        }(server, compileMiddlewareAPI, root);
+            if (watchPaths.length) return startWatchFiles(prepareWatchOptions(watchPaths), compilationManager, root);
+        }(server, compilationManager, root);
         return {
             async close () {
                 await Promise.all([
@@ -5021,12 +5014,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             }
         };
     }
-    async function watchDevFiles(devConfig, compileMiddlewareAPI, root) {
+    async function watchDevFiles(devConfig, compilationManager, root) {
         let { watchFiles } = devConfig;
         if (!watchFiles) return;
         let watchers = [];
         for (let { paths, options, type } of castArray(watchFiles)){
-            let watchOptions = prepareWatchOptions(paths, options, type), watcher = await startWatchFiles(watchOptions, compileMiddlewareAPI, root);
+            let watchOptions = prepareWatchOptions(paths, options, type), watcher = await startWatchFiles(watchOptions, compilationManager, root);
             watcher && watchers.push(watcher);
         }
         return async ()=>{
@@ -5054,11 +5047,13 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }
         return chokidar.watch(Array.from(watchFiles), options);
     }
-    async function startWatchFiles({ paths, options, type = 'reload-page' }, compileMiddlewareAPI, root) {
+    async function startWatchFiles({ paths, options, type = 'reload-page' }, compilationManager, root) {
         if ('reload-page' !== type) return;
         let watcher = await createChokidar(paths, root, options);
         return watcher.on('change', ()=>{
-            compileMiddlewareAPI.sockWrite('static-changed');
+            compilationManager.socketServer.sockWrite({
+                type: 'static-changed'
+            });
         }), watcher;
     }
     let cleaners = [], onBeforeRestartServer = (cleaner)=>{
@@ -5200,37 +5195,39 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
     }, isNodeCompiler = (compiler)=>{
         let { target } = compiler.options;
         return !!target && (Array.isArray(target) ? target.includes('node') : 'node' === target);
-    }, setupServerHooks = (compiler, hookCallbacks)=>{
+    }, setupServerHooks = (compiler, { onDone, onInvalid })=>{
         if (isNodeCompiler(compiler)) return;
         let { compile, invalid, done } = compiler.hooks;
         compile.tap('rsbuild-dev-server', ()=>{
-            hookCallbacks.onInvalid(getCompilationId(compiler));
+            onInvalid(getCompilationId(compiler));
         }), invalid.tap('rsbuild-dev-server', (fileName)=>{
-            hookCallbacks.onInvalid(getCompilationId(compiler), fileName);
-        }), done.tap('rsbuild-dev-server', hookCallbacks.onDone);
-    }, getDevMiddleware = async (multiCompiler)=>{
-        let { default: rsbuildDevMiddleware } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/rsbuild-dev-middleware/index.js"));
-        return async (options)=>{
-            let { clientPaths, clientConfig, callbacks, liveReload, serverConfig, ...restOptions } = options, resolvedClientConfig = await getResolvedClientConfig(clientConfig, serverConfig);
-            return applyToCompiler(multiCompiler, (compiler)=>{
-                clientPaths && function({ compiler, clientPaths, clientConfig = {}, resolvedClientConfig = {}, liveReload = !0 }) {
-                    if (isClientCompiler(compiler)) for (let clientPath of (new compiler.webpack.DefinePlugin({
-                        RSBUILD_COMPILATION_NAME: JSON.stringify(getCompilationId(compiler)),
-                        RSBUILD_CLIENT_CONFIG: JSON.stringify(clientConfig),
-                        RSBUILD_RESOLVED_CLIENT_CONFIG: JSON.stringify(resolvedClientConfig),
-                        RSBUILD_DEV_LIVE_RELOAD: liveReload
-                    }).apply(compiler), clientPaths))new compiler.webpack.EntryPlugin(compiler.context, clientPath, {
-                        name: void 0
-                    }).apply(compiler);
-                }({
-                    compiler,
-                    clientPaths,
-                    clientConfig,
-                    resolvedClientConfig,
-                    liveReload
-                }), setupServerHooks(compiler, callbacks);
-            }), rsbuildDevMiddleware(multiCompiler, restOptions);
-        };
+            onInvalid(getCompilationId(compiler), fileName);
+        }), done.tap('rsbuild-dev-server', onDone);
+    }, getCompilationMiddleware = async (compiler, options)=>{
+        let { default: rsbuildDevMiddleware } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/rsbuild-dev-middleware/index.js")), { clientPaths, callbacks, devConfig, serverConfig } = options, resolvedClientConfig = await getResolvedClientConfig(devConfig.client, serverConfig);
+        return applyToCompiler(compiler, (compiler)=>{
+            clientPaths && function({ compiler, clientPaths, devConfig, resolvedClientConfig }) {
+                if (isClientCompiler(compiler)) for (let clientPath of (new compiler.webpack.DefinePlugin({
+                    RSBUILD_COMPILATION_NAME: JSON.stringify(getCompilationId(compiler)),
+                    RSBUILD_CLIENT_CONFIG: JSON.stringify(devConfig.client),
+                    RSBUILD_RESOLVED_CLIENT_CONFIG: JSON.stringify(resolvedClientConfig),
+                    RSBUILD_DEV_LIVE_RELOAD: devConfig.liveReload
+                }).apply(compiler), clientPaths))new compiler.webpack.EntryPlugin(compiler.context, clientPath, {
+                    name: void 0
+                }).apply(compiler);
+            }({
+                compiler,
+                clientPaths,
+                devConfig,
+                resolvedClientConfig
+            }), setupServerHooks(compiler, callbacks);
+        }), rsbuildDevMiddleware(compiler, {
+            etag: 'weak',
+            publicPath: '/',
+            stats: !1,
+            serverSideRender: !0,
+            writeToDisk: devConfig.writeToDisk
+        });
     }, external_node_querystring_namespaceObject = require("node:querystring"), styles = {
         1: 'font-weight:bold',
         2: 'opacity:0.5',
@@ -5277,11 +5274,6 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }) : obj[key] = value, obj;
     }
     class SocketServer {
-        upgrade(req, sock, head) {
-            this.wsServer.shouldHandle(req) && this.wsServer.handleUpgrade(req, sock, head, (connection)=>{
-                this.wsServer.emit('connection', connection, req);
-            });
-        }
         clearHeartbeatTimer() {
             this.heartbeatTimer && (clearInterval(this.heartbeatTimer), this.heartbeatTimer = null);
         }
@@ -5551,13 +5543,17 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             1 === connection.readyState && connection.send(message);
         }
         constructor(options){
-            socketServer_define_property(this, "wsServer", void 0), socketServer_define_property(this, "sockets", []), socketServer_define_property(this, "options", void 0), socketServer_define_property(this, "stats", void 0), socketServer_define_property(this, "initialChunks", void 0), socketServer_define_property(this, "heartbeatTimer", null), socketServer_define_property(this, "checkSockets", ()=>{
+            socketServer_define_property(this, "wsServer", void 0), socketServer_define_property(this, "sockets", []), socketServer_define_property(this, "options", void 0), socketServer_define_property(this, "stats", void 0), socketServer_define_property(this, "initialChunks", void 0), socketServer_define_property(this, "heartbeatTimer", null), socketServer_define_property(this, "upgrade", (req, sock, head)=>{
+                this.wsServer.shouldHandle(req) && this.wsServer.handleUpgrade(req, sock, head, (connection)=>{
+                    this.wsServer.emit('connection', connection, req);
+                });
+            }), socketServer_define_property(this, "checkSockets", ()=>{
                 for (let socket of this.wsServer.clients)socket.isAlive ? (socket.isAlive = !1, socket.ping(()=>{})) : socket.terminate();
                 null !== this.heartbeatTimer && (this.heartbeatTimer = setTimeout(this.checkSockets, 30000).unref());
             }), this.options = options, this.stats = {}, this.initialChunks = {};
         }
     }
-    function compilerDevMiddleware_define_property(obj, key, value) {
+    function compilationManager_define_property(obj, key, value) {
         return key in obj ? Object.defineProperty(obj, key, {
             value: value,
             enumerable: !0,
@@ -5565,7 +5561,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             writable: !0
         }) : obj[key] = value, obj;
     }
-    let compilerDevMiddleware_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__), formatDevConfig = (config, environments)=>{
+    let compilationManager_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__), formatDevConfig = (config, environments)=>{
         let writeToDiskValues = Object.values(environments).map((env)=>env.config.dev.writeToDisk);
         return 1 === new Set(writeToDiskValues).size ? {
             ...config,
@@ -5578,13 +5574,11 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             }
         };
     };
-    class CompilerDevMiddleware {
+    class CompilationManager {
         async init() {
-            let devMiddleware = await getDevMiddleware(this.compiler);
-            this.middleware = await this.setupDevMiddleware(devMiddleware, this.publicPaths), await this.socketServer.prepare();
-        }
-        upgrade(req, sock, head) {
-            this.socketServer.upgrade(req, sock, head);
+            await this.setupCompilationMiddleware(), await this.socketServer.prepare();
+            let { compiler } = this;
+            this.outputFileSystem = (helpers_isMultiCompiler(compiler) ? compiler.compilers[0].outputFileSystem : compiler.outputFileSystem) || external_node_fs_default();
         }
         async close() {
             await this.socketServer.close(), this.middleware && await new Promise((resolve)=>{
@@ -5597,21 +5591,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 });
             });
         }
-        sockWrite(type, data) {
-            this.socketServer.sockWrite({
-                type,
-                data
-            });
-        }
-        async setupDevMiddleware(devMiddleware, publicPaths) {
-            let { devConfig, serverConfig } = this, { headers, base } = serverConfig, clientPaths = function(devConfig) {
+        async setupCompilationMiddleware() {
+            let { devConfig, serverConfig, publicPaths } = this, clientPaths = function(devConfig) {
                 var _devConfig_client;
                 let clientPaths = [];
-                return (devConfig.hmr || devConfig.liveReload) && (clientPaths.push(compilerDevMiddleware_require.resolve('@rsbuild/core/client/hmr')), (null === (_devConfig_client = devConfig.client) || void 0 === _devConfig_client ? void 0 : _devConfig_client.overlay) && clientPaths.push(`${compilerDevMiddleware_require.resolve('@rsbuild/core/client/overlay')}`)), clientPaths;
-            }(devConfig), middleware = await devMiddleware({
-                headers,
-                publicPath: '/',
-                stats: !1,
+                return (devConfig.hmr || devConfig.liveReload) && (clientPaths.push(compilationManager_require.resolve('@rsbuild/core/client/hmr')), (null === (_devConfig_client = devConfig.client) || void 0 === _devConfig_client ? void 0 : _devConfig_client.overlay) && clientPaths.push(`${compilationManager_require.resolve('@rsbuild/core/client/overlay')}`)), clientPaths;
+            }(devConfig), middleware = await getCompilationMiddleware(this.compiler, {
                 callbacks: {
                     onInvalid: (compilationId, fileName)=>{
                         if ('string' == typeof fileName && HTML_REGEX.test(fileName)) {
@@ -5630,307 +5615,46 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         this.socketServer.updateStats(stats);
                     }
                 },
-                clientPaths: clientPaths,
-                clientConfig: devConfig.client,
-                liveReload: devConfig.liveReload,
-                writeToDisk: devConfig.writeToDisk,
-                serverSideRender: !0,
-                etag: 'weak',
+                clientPaths,
+                devConfig,
                 serverConfig
-            }), assetPrefixes = publicPaths.map(pathnameParse).map((prefix)=>base && '/' !== base ? stripBase(prefix, base) : prefix), wrapper = async (req, res, next)=>{
+            }), { base } = serverConfig, assetPrefixes = publicPaths.map(pathnameParse).map((prefix)=>base && '/' !== base ? stripBase(prefix, base) : prefix), wrapper = async (req, res, next)=>{
                 let { url } = req, assetPrefix = url && assetPrefixes.find((prefix)=>url.startsWith(prefix));
                 assetPrefix && '/' !== assetPrefix ? (req.url = url.slice(assetPrefix.length - 1), middleware(req, res, (...args)=>{
                     req.url = url, next(...args);
                 })) : middleware(req, res, next);
             };
-            return wrapper.close = middleware.close, wrapper;
+            wrapper.close = middleware.close, this.middleware = wrapper;
         }
         constructor({ dev, server, compiler, publicPaths, environments }){
-            compilerDevMiddleware_define_property(this, "middleware", void 0), compilerDevMiddleware_define_property(this, "devConfig", void 0), compilerDevMiddleware_define_property(this, "serverConfig", void 0), compilerDevMiddleware_define_property(this, "compiler", void 0), compilerDevMiddleware_define_property(this, "publicPaths", void 0), compilerDevMiddleware_define_property(this, "socketServer", void 0), this.devConfig = formatDevConfig(dev, environments), this.serverConfig = server, this.compiler = compiler, this.publicPaths = publicPaths, this.socketServer = new SocketServer(dev);
+            compilationManager_define_property(this, "middleware", void 0), compilationManager_define_property(this, "outputFileSystem", void 0), compilationManager_define_property(this, "devConfig", void 0), compilationManager_define_property(this, "serverConfig", void 0), compilationManager_define_property(this, "compiler", void 0), compilationManager_define_property(this, "publicPaths", void 0), compilationManager_define_property(this, "socketServer", void 0), compilationManager_define_property(this, "readFileSync", (fileName)=>'readFileSync' in this.outputFileSystem ? this.outputFileSystem.readFileSync(fileName, 'utf-8') : external_node_fs_default().readFileSync(fileName, 'utf-8')), this.devConfig = formatDevConfig(dev, environments), this.serverConfig = server, this.compiler = compiler, this.publicPaths = publicPaths, this.outputFileSystem = external_node_fs_default(), this.socketServer = new SocketServer(dev);
         }
     }
-    let external_node_vm_namespaceObject = require("node:vm");
-    var external_node_vm_default = __webpack_require__.n(external_node_vm_namespaceObject);
-    let SYNTHETIC_MODULES_STORE = '__SYNTHETIC_MODULES_STORE', asModule = async (something, context, unlinked)=>{
-        if (something instanceof external_node_vm_default().Module) return something;
-        context[SYNTHETIC_MODULES_STORE] = context[SYNTHETIC_MODULES_STORE] || [];
-        let i = context[SYNTHETIC_MODULES_STORE].length;
-        context[SYNTHETIC_MODULES_STORE].push(something);
-        let code = [
-            ...new Set([
-                'default',
-                ...Object.keys(something)
-            ])
-        ].map((name)=>`const _${name} = ${SYNTHETIC_MODULES_STORE}[${i}]${'default' === name ? '' : `[${JSON.stringify(name)}]`}; export { _${name} as ${name}};`).join('\n'), m = new (external_node_vm_default()).SourceTextModule(code, {
-            context
-        });
-        return unlinked || (await m.link(()=>{}), m.instantiate && m.instantiate(), await m.evaluate()), m;
-    };
-    function basic_define_property(obj, key, value) {
-        return key in obj ? Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: !0,
-            configurable: !0,
-            writable: !0
-        }) : obj[key] = value, obj;
-    }
-    let isRelativePath = (p)=>/^\.\.?\//.test(p), getSubPath = (p)=>{
-        let lastSlash = p.lastIndexOf('/'), firstSlash = p.indexOf('/');
-        if (-1 !== lastSlash && firstSlash !== lastSlash) {
-            if (-1 !== firstSlash) {
-                let next = p.indexOf('/', firstSlash + 1), dir = p.slice(firstSlash + 1, next);
-                for(; '.' === dir;)firstSlash = next, next = p.indexOf('/', firstSlash + 1), dir = p.slice(firstSlash + 1, next);
+    let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i, shouldCompress = (res)=>{
+        if (res.getHeader('Content-Encoding')) return !1;
+        let contentType = String(res.getHeader('Content-Type'));
+        if (contentType && !CONTENT_TYPE_REGEX.test(contentType)) return !1;
+        let size = res.getHeader('Content-Length');
+        return void 0 === size || Number(size) > 1024;
+    }, gzipMiddleware = ({ level = external_node_zlib_default().constants.Z_BEST_SPEED } = {})=>(req, res, next)=>{
+            let gzip, writeHeadStatus;
+            let accept = req.headers['accept-encoding'], encoding = 'string' == typeof accept && ENCODING_REGEX.test(accept);
+            if ('HEAD' === req.method || !encoding) {
+                next();
+                return;
             }
-            return p.slice(firstSlash + 1, lastSlash + 1);
-        }
-        return '';
-    };
-    class BasicRunner {
-        run(file) {
-            this.globalContext || (this.globalContext = this.createGlobalContext()), this.baseModuleScope = this.createBaseModuleScope(), this.createRunner();
-            let res = this.getRequire()(this._options.dist, file.startsWith('./') ? file : `./${file}`);
-            return 'object' == typeof res && 'then' in res ? res : Promise.resolve(res);
-        }
-        getRequire() {
-            let entryRequire = this.requirers.get('entry');
-            return (currentDirectory, modulePath, context = {})=>entryRequire(currentDirectory, Array.isArray(modulePath) ? modulePath : modulePath.split('?')[0], context);
-        }
-        getFile(modulePath, currentDirectory) {
-            if (Array.isArray(modulePath)) return {
-                path: external_node_path_default().join(currentDirectory, '.array-require.js'),
-                content: `module.exports = (${modulePath.map((arg)=>`require(${JSON.stringify(`./${arg}`)})`).join(', ')});`,
-                subPath: ''
-            };
-            let joinedPath = isRelativePath(modulePath) ? external_node_path_default().join(currentDirectory, modulePath) : modulePath;
-            return this._options.isBundleOutput(joinedPath) ? {
-                path: joinedPath,
-                content: this._options.readFileSync(joinedPath),
-                subPath: getSubPath(modulePath)
-            } : null;
-        }
-        preExecute(_code, _file) {}
-        postExecute(_m, _file) {}
-        createRunner() {
-            this.requirers.set('entry', (_currentDirectory, _modulePath, _context = {})=>{
-                throw Error('[rsbuild:runner] Not implement');
-            });
-        }
-        constructor(_options){
-            basic_define_property(this, "_options", void 0), basic_define_property(this, "globalContext", void 0), basic_define_property(this, "baseModuleScope", void 0), basic_define_property(this, "requirers", void 0), this._options = _options, this.globalContext = null, this.baseModuleScope = null, this.requirers = new Map();
-        }
-    }
-    let cjs_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__), cjs_define = (...args)=>{
-        args.pop()();
-    };
-    class CommonJsRunner extends BasicRunner {
-        createGlobalContext() {
-            return {
-                console: console,
-                setTimeout: (cb, ms, ...args)=>{
-                    let timeout = setTimeout(cb, ms, ...args);
-                    return timeout.unref(), timeout;
-                },
-                clearTimeout: clearTimeout,
-                queueMicrotask
-            };
-        }
-        createBaseModuleScope() {
-            return {
-                console: this.globalContext.console,
-                setTimeout: this.globalContext.setTimeout,
-                clearTimeout: this.globalContext.clearTimeout,
-                nsObj: (m)=>(Object.defineProperty(m, Symbol.toStringTag, {
-                        value: 'Module'
-                    }), m),
-                queueMicrotask
-            };
-        }
-        createModuleScope(requireFn, m, file) {
-            return {
-                ...this.baseModuleScope,
-                require: requireFn.bind(null, external_node_path_default().dirname(file.path)),
-                module: m,
-                exports: m.exports,
-                __dirname: external_node_path_default().dirname(file.path),
-                __filename: file.path,
-                define: cjs_define
-            };
-        }
-        createRunner() {
-            this.requirers.set('miss', this.createMissRequirer()), this.requirers.set('entry', this.createCjsRequirer());
-        }
-        createMissRequirer() {
-            return (_currentDirectory, modulePath, _context = {})=>{
-                let resolvedPath = cjs_require.resolve(modulePath, {
-                    paths: [
-                        _currentDirectory
-                    ]
-                });
-                return cjs_require(resolvedPath.startsWith('node:') ? resolvedPath.slice(5) : resolvedPath);
-            };
-        }
-        createCjsRequirer() {
-            let requireCache = Object.create(null);
-            return (currentDirectory, modulePath, context = {})=>{
-                let file = context.file || this.getFile(modulePath, currentDirectory);
-                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
-                if (file.path in requireCache) return requireCache[file.path].exports;
-                let m = {
-                    exports: {}
-                };
-                requireCache[file.path] = m;
-                let currentModuleScope = this.createModuleScope(this.getRequire(), m, file), args = Object.keys(currentModuleScope), argValues = args.map((arg)=>currentModuleScope[arg]), code = `(function(${args.join(', ')}) {
-        ${file.content}
-      })`;
-                this.preExecute(code, file);
-                let dynamicImport = Function('specifier', 'return import(specifier)');
-                return external_node_vm_default().runInThisContext(code, {
-                    filename: file.path,
-                    importModuleDynamically: async (specifier)=>await dynamicImport(specifier)
-                }).call(m.exports, ...argValues), this.postExecute(m, file), m.exports;
-            };
-        }
-    }
-    var type_EsmMode = function(EsmMode) {
-        return EsmMode[EsmMode.Unknown = 0] = "Unknown", EsmMode[EsmMode.Evaluated = 1] = "Evaluated", EsmMode[EsmMode.Unlinked = 2] = "Unlinked", EsmMode;
-    }({});
-    class EsmRunner extends CommonJsRunner {
-        createRunner() {
-            var _this__options_compilerOptions_experiments;
-            super.createRunner(), this.requirers.set('cjs', this.getRequire()), this.requirers.set('esm', this.createEsmRequirer());
-            let outputModule = null === (_this__options_compilerOptions_experiments = this._options.compilerOptions.experiments) || void 0 === _this__options_compilerOptions_experiments ? void 0 : _this__options_compilerOptions_experiments.outputModule;
-            this.requirers.set('entry', (currentDirectory, modulePath, context)=>{
-                let file = this.getFile(modulePath, currentDirectory);
-                return file ? outputModule && !file.path.endsWith('.cjs') ? this.requirers.get('esm')(currentDirectory, modulePath, {
-                    ...context,
-                    file
-                }) : this.requirers.get('cjs')(currentDirectory, modulePath, {
-                    ...context,
-                    file
-                }) : this.requirers.get('miss')(currentDirectory, modulePath);
-            });
-        }
-        createEsmRequirer() {
-            let esmContext = external_node_vm_default().createContext(this.baseModuleScope, {
-                name: 'context for esm'
-            }), esmCache = new Map(), esmIdentifier = this._options.name;
-            return (currentDirectory, modulePath, context = {})=>{
-                if (!external_node_vm_default().SourceTextModule) throw Error('[rsbuild:runner] Running ESM bundle needs add Node.js option "--experimental-vm-modules".');
-                let _require = this.getRequire(), file = context.file || this.getFile(modulePath, currentDirectory);
-                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
-                let esm = esmCache.get(file.path);
-                return (esm || (esm = new (external_node_vm_default()).SourceTextModule(file.content, {
-                    identifier: `${esmIdentifier}-${file.path}`,
-                    url: `${(0, external_node_url_namespaceObject.pathToFileURL)(file.path).href}?${esmIdentifier}`,
-                    context: esmContext,
-                    initializeImportMeta: (meta, _)=>{
-                        meta.url = (0, external_node_url_namespaceObject.pathToFileURL)(file.path).href;
-                    },
-                    importModuleDynamically: async (specifier, module)=>{
-                        let result = await _require(external_node_path_default().dirname(file.path), specifier, {
-                            esmMode: type_EsmMode.Evaluated
-                        });
-                        return await asModule(result, module.context);
-                    }
-                }), esmCache.set(file.path, esm)), context.esmMode === type_EsmMode.Unlinked) ? esm : (async ()=>{
-                    if (await esm.link(async (specifier, referencingModule)=>await asModule(await _require(external_node_path_default().dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : (0, external_node_url_namespaceObject.fileURLToPath)(referencingModule.url)), specifier, {
-                            esmMode: type_EsmMode.Unlinked
-                        }), referencingModule.context, !0)), esm.instantiate && esm.instantiate(), await esm.evaluate(), context.esmMode === type_EsmMode.Evaluated) return esm;
-                    let ns = esm.namespace;
-                    return ns.default && ns.default instanceof Promise ? ns.default : ns;
-                })();
-            };
-        }
-    }
-    class BasicRunnerFactory {
-        create(options) {
-            return this.createRunner(options);
-        }
-        createRunner(options) {
-            let runnerOptions = {
-                name: this.name,
-                ...options
-            }, { compilerOptions } = options;
-            if ('web' === compilerOptions.target || 'webworker' === compilerOptions.target) throw Error(`[rsbuild:runner] Not support run "${compilerOptions.target}" resource in Rsbuild server`);
-            return new EsmRunner(runnerOptions);
-        }
-        constructor(name){
-            !function(obj, key, value) {
-                key in obj ? Object.defineProperty(obj, key, {
-                    value: value,
-                    enumerable: !0,
-                    configurable: !0,
-                    writable: !0
-                }) : obj[key] = value;
-            }(this, "name", void 0), this.name = name;
-        }
-    }
-    let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunnerFactory(bundlePath).create(runnerFactoryOptions).run(bundlePath), loadBundle = async (stats, entryName, utils)=>{
-        let { chunks, entrypoints, outputPath } = stats.toJson({
-            all: !1,
-            chunks: !0,
-            entrypoints: !0,
-            outputPath: !0
-        });
-        if (!(null == entrypoints ? void 0 : entrypoints[entryName])) throw Error(`[rsbuild:loadBundle] Can't find entry: "${entryName}"`);
-        let { chunks: entryChunks = [] } = entrypoints[entryName], files = entryChunks.reduce((prev, entryChunkName)=>{
-            let chunk = null == chunks ? void 0 : chunks.find((chunk)=>{
-                var _chunk_names;
-                return chunk.entry && (null === (_chunk_names = chunk.names) || void 0 === _chunk_names ? void 0 : _chunk_names.includes(String(entryChunkName)));
-            });
-            return (null == chunk ? void 0 : chunk.files) ? prev.concat(chunk.files.filter((file)=>!file.endsWith('.css'))) : prev;
-        }, []);
-        if (0 === files.length) throw Error(`[rsbuild:loadBundle] Failed to get bundle by entryName: "${entryName}"`);
-        if (files.length > 1) throw Error(`[rsbuild:loadBundle] Only support load single entry chunk, but got ${files.length}: ${files.join(',')}`);
-        let allChunkFiles = (null == chunks ? void 0 : chunks.flatMap((c)=>c.files).map((file)=>(0, external_node_path_namespaceObject.join)(outputPath, file))) || [];
-        return await runner_run({
-            bundlePath: files[0],
-            dist: outputPath,
-            compilerOptions: stats.compilation.options,
-            readFileSync: utils.readFileSync,
-            isBundleOutput: (modulePath)=>allChunkFiles.includes(modulePath)
-        });
-    }, getTransformedHtml = async (entryName, utils)=>{
-        let { htmlPaths, distPath } = utils.environment, htmlPath = htmlPaths[entryName];
-        if (!htmlPath) throw Error(`[rsbuild:getTransformedHtml] Failed to get HTML file by entryName: "${entryName}"`);
-        let fileName = (0, external_node_path_namespaceObject.join)(distPath, htmlPath);
-        return utils.readFileSync(fileName);
-    }, createCacheableFunction = (getter)=>{
-        let cache = new WeakMap();
-        return async (stats, entryName, utils)=>{
-            let cachedEntries = cache.get(stats);
-            if (null == cachedEntries ? void 0 : cachedEntries[entryName]) return cachedEntries[entryName];
-            let res = await getter(stats, entryName, utils);
-            return cache.set(stats, {
-                ...cachedEntries || {},
-                [entryName]: res
-            }), res;
-        };
-    }, ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i, shouldCompress = (res)=>{
-        if (res.getHeader('Content-Encoding')) return !1;
-        let contentType = String(res.getHeader('Content-Type'));
-        if (contentType && !CONTENT_TYPE_REGEX.test(contentType)) return !1;
-        let size = res.getHeader('Content-Length');
-        return void 0 === size || Number(size) > 1024;
-    }, gzipMiddleware = ({ level = external_node_zlib_default().constants.Z_BEST_SPEED } = {})=>(req, res, next)=>{
-            let gzip, writeHeadStatus;
-            let accept = req.headers['accept-encoding'], encoding = 'string' == typeof accept && ENCODING_REGEX.test(accept);
-            if ('HEAD' === req.method || !encoding) {
-                next();
-                return;
-            }
-            let started = !1, { end, write, on, writeHead } = res, listeners = [], start = ()=>{
-                if (!started) {
-                    if (started = !0, shouldCompress(res)) for (let listener of (res.setHeader('Content-Encoding', 'gzip'), res.removeHeader('Content-Length'), (gzip = external_node_zlib_default().createGzip({
-                        level
-                    })).on('data', (chunk)=>{
-                        !1 === write.call(res, chunk) && gzip.pause();
-                    }), on.call(res, 'drain', ()=>gzip.resume()), gzip.on('end', ()=>{
-                        end.call(res);
-                    }), listeners))gzip.on.apply(gzip, listener);
-                    else for (let listener of listeners)on.apply(res, listener);
-                    writeHead.call(res, writeHeadStatus ?? res.statusCode);
-                }
+            let started = !1, { end, write, on, writeHead } = res, listeners = [], start = ()=>{
+                if (!started) {
+                    if (started = !0, shouldCompress(res)) for (let listener of (res.setHeader('Content-Encoding', 'gzip'), res.removeHeader('Content-Length'), (gzip = external_node_zlib_default().createGzip({
+                        level
+                    })).on('data', (chunk)=>{
+                        !1 === write.call(res, chunk) && gzip.pause();
+                    }), on.call(res, 'drain', ()=>gzip.resume()), gzip.on('end', ()=>{
+                        end.call(res);
+                    }), listeners))gzip.on.apply(gzip, listener);
+                    else for (let listener of listeners)on.apply(res, listener);
+                    writeHead.call(res, writeHeadStatus ?? res.statusCode);
+                }
             };
             res.writeHead = (status, reason, headers)=>{
                 if (reason) for (let [key, value] of Object.entries(headers || reason))res.setHeader(key, value);
@@ -5966,17 +5690,17 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         if (!req.url || !req.headers || 'GET' !== req.method && 'HEAD' !== req.method) return !1;
         let { accept } = req.headers;
         return 'string' == typeof accept && (accept.includes('text/html') || accept.includes('*/*'));
-    }, postfixRE = /[?#].*$/, getUrlPathname = (url)=>url.replace(postfixRE, ''), getHtmlCompletionMiddleware = ({ distPath, callback, outputFileSystem })=>async (req, res, next)=>{
+    }, postfixRE = /[?#].*$/, getUrlPathname = (url)=>url.replace(postfixRE, ''), getHtmlCompletionMiddleware = ({ distPath, compilationManager })=>async (req, res, next)=>{
             if (!maybeHTMLRequest(req)) return next();
-            let pathname = getUrlPathname(req.url), rewrite = (newUrl)=>(req.url = newUrl, callback(req, res, (...args)=>{
+            let pathname = getUrlPathname(req.url), rewrite = (newUrl)=>(req.url = newUrl, compilationManager.middleware(req, res, (...args)=>{
                     next(...args);
                 }));
             if (pathname.endsWith('/')) {
                 let newUrl = `${pathname}index.html`, filePath = external_node_path_default().join(distPath, newUrl);
-                if (await middlewares_isFileExists(filePath, outputFileSystem)) return rewrite(newUrl);
+                if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return rewrite(newUrl);
             } else if (!external_node_path_default().extname(pathname)) {
                 let newUrl = `${pathname}.html`, filePath = external_node_path_default().join(distPath, newUrl);
-                if (await middlewares_isFileExists(filePath, outputFileSystem)) return rewrite(newUrl);
+                if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return rewrite(newUrl);
             }
             next();
         }, getBaseMiddleware = ({ base })=>async (req, res, next)=>{
@@ -5999,12 +5723,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             res.writeHead(404, {
                 'Content-Type': 'text/plain'
             }), res.end(`The server is configured with a base URL of ${base} - did you mean to visit ${redirectPath} instead?`);
-        }, getHtmlFallbackMiddleware = ({ htmlFallback, distPath, callback, outputFileSystem })=>async (req, res, next)=>{
+        }, getHtmlFallbackMiddleware = ({ htmlFallback, distPath, compilationManager })=>async (req, res, next)=>{
             if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url || 'index' !== htmlFallback) return next();
             let filePath = external_node_path_default().join(distPath, 'index.html');
-            if (await middlewares_isFileExists(filePath, outputFileSystem)) {
+            if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) {
                 let newUrl = '/index.html';
-                return 'verbose' === rslog_index_js_namespaceObject.logger.level && rslog_index_js_namespaceObject.logger.debug(`${req.method} ${index_js_default().gray(`${req.url} ${index_js_default().yellow('fallback')} to ${newUrl}`)}`), req.url = newUrl, callback(req, res, (...args)=>next(...args));
+                return 'verbose' === rslog_index_js_namespaceObject.logger.level && rslog_index_js_namespaceObject.logger.debug(`${req.method} ${index_js_default().gray(`${req.url} ${index_js_default().yellow('fallback')} to ${newUrl}`)}`), req.url = newUrl, compilationManager.middleware(req, res, (...args)=>next(...args));
             }
             next();
         }, viewingServedFilesMiddleware = ({ environments })=>async (req, res, next)=>{
@@ -6096,9 +5820,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 for (let middleware of proxyMiddlewares)'function' == typeof middleware.upgrade && middleware.upgrade(req, socket, head);
             }
         };
-    }, applySetupMiddlewares = (dev, environments, compileMiddlewareAPI)=>{
+    }, applySetupMiddlewares = (dev, environments, compilationManager)=>{
         let setupMiddlewares = dev.setupMiddlewares || [], serverOptions = {
-            sockWrite: (type, data)=>null == compileMiddlewareAPI ? void 0 : compileMiddlewareAPI.sockWrite(type, data),
+            sockWrite: (type, data)=>null == compilationManager ? void 0 : compilationManager.socketServer.sockWrite({
+                    type,
+                    data
+                }),
             environments
         }, before = [], after = [];
         for (let handler of setupMiddlewares)handler({
@@ -6109,13 +5836,9 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             before,
             after
         };
-    }, applyDefaultMiddlewares = async ({ middlewares, server, compileMiddlewareAPI, output, pwd, outputFileSystem, environments, postCallbacks })=>{
+    }, applyDefaultMiddlewares = async ({ dev, middlewares, server, compilationManager, context, pwd, environments, postCallbacks })=>{
         let upgradeEvents = [];
-        if (server.compress && middlewares.push(gzipMiddleware()), middlewares.push((req, res, next)=>{
-            var _parseUrl;
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            let path = req.url ? null === (_parseUrl = parseUrl(req.url)) || void 0 === _parseUrl ? void 0 : _parseUrl.pathname : '';
-            (null == path ? void 0 : path.includes('hot-update')) && res.setHeader('Access-Control-Allow-Credentials', 'false');
+        if (server.compress && middlewares.push(gzipMiddleware()), middlewares.push((_req, res, next)=>{
             let confHeaders = server.headers;
             if (confHeaders) for (let [key, value] of Object.entries(confHeaders))res.setHeader(key, value);
             next();
@@ -6123,6 +5846,10 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             let { default: corsMiddleware } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/cors/index.js"));
             middlewares.push(corsMiddleware('boolean' == typeof server.cors ? {} : server.cors));
         }
+        if ('dev' === context.action && 'rspack' === context.bundlerType && dev.lazyCompilation && compilationManager) {
+            let { compiler } = compilationManager;
+            middlewares.push(core_default().experiments.lazyCompilationMiddleware(helpers_isMultiCompiler(compiler) ? compiler.compilers[0] : compiler, dev.lazyCompilation));
+        }
         if (server.proxy) {
             let { middlewares: proxyMiddlewares, upgrade } = await createProxyMiddleware(server.proxy);
             for (let middleware of (upgradeEvents.push(upgrade), proxyMiddlewares))middlewares.push(middleware);
@@ -6131,20 +5858,17 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             base: server.base
         }));
         let { default: launchEditorMiddleware } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/launch-editor-middleware/index.js"));
-        middlewares.push([
+        for (let publicDir of (middlewares.push([
             '/__open-in-editor',
             launchEditorMiddleware()
         ]), middlewares.push(viewingServedFilesMiddleware({
             environments
-        })), compileMiddlewareAPI && (middlewares.push(compileMiddlewareAPI.middleware), upgradeEvents.push(compileMiddlewareAPI.onUpgrade.bind(compileMiddlewareAPI)), middlewares.push((req, res, next)=>{
+        })), compilationManager && (middlewares.push(compilationManager.middleware), upgradeEvents.push(compilationManager.socketServer.upgrade), middlewares.push((req, res, next)=>{
             var _req_url;
             (null === (_req_url = req.url) || void 0 === _req_url ? void 0 : _req_url.endsWith('.hot-update.json')) && 'OPTIONS' !== req.method ? (res.statusCode = 404, res.end()) : next();
-        }));
-        let distPath = (0, external_node_path_namespaceObject.isAbsolute)(output.distPath) ? output.distPath : (0, external_node_path_namespaceObject.join)(pwd, output.distPath);
-        for (let publicDir of (compileMiddlewareAPI && middlewares.push(getHtmlCompletionMiddleware({
-            distPath,
-            callback: compileMiddlewareAPI.middleware,
-            outputFileSystem
+        })), compilationManager && middlewares.push(getHtmlCompletionMiddleware({
+            compilationManager,
+            distPath: context.distPath
         })), normalizePublicDirs(null == server ? void 0 : server.publicDir))){
             let { default: sirv } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/sirv/index.js")), { name } = publicDir, assetMiddleware = sirv((0, external_node_path_namespaceObject.isAbsolute)(name) ? name : (0, external_node_path_namespaceObject.join)(pwd, name), {
                 etag: !0,
@@ -6153,24 +5877,23 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             middlewares.push(assetMiddleware);
         }
         for (let callback of postCallbacks)callback();
-        if (compileMiddlewareAPI && middlewares.push(getHtmlFallbackMiddleware({
-            distPath,
-            callback: compileMiddlewareAPI.middleware,
-            htmlFallback: server.htmlFallback,
-            outputFileSystem
+        if (compilationManager && middlewares.push(getHtmlFallbackMiddleware({
+            compilationManager,
+            distPath: context.distPath,
+            htmlFallback: server.htmlFallback
         })), server.historyApiFallback) {
             let { default: connectHistoryApiFallback } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/connect-history-api-fallback/index.js")), historyApiFallbackMiddleware = connectHistoryApiFallback(!0 === server.historyApiFallback ? {} : server.historyApiFallback);
-            middlewares.push(historyApiFallbackMiddleware), (null == compileMiddlewareAPI ? void 0 : compileMiddlewareAPI.middleware) && middlewares.push(compileMiddlewareAPI.middleware);
+            middlewares.push(historyApiFallbackMiddleware), (null == compilationManager ? void 0 : compilationManager.middleware) && middlewares.push(compilationManager.middleware);
         }
         return middlewares.push(faviconFallbackMiddleware), {
             onUpgrade: (...args)=>{
                 for (let cb of upgradeEvents)cb(...args);
             }
         };
-    }, getMiddlewares = async (options)=>{
-        let middlewares = [], { environments, compileMiddlewareAPI } = options;
+    }, getDevMiddlewares = async (options)=>{
+        let middlewares = [], { environments, compilationManager } = options;
         'verbose' === rslog_index_js_namespaceObject.logger.level && middlewares.push(await getRequestLoggerMiddleware());
-        let { before, after } = applySetupMiddlewares(options.dev, environments, compileMiddlewareAPI);
+        let { before, after } = applySetupMiddlewares(options.dev, environments, compilationManager);
         middlewares.push(...before);
         let { onUpgrade } = await applyDefaultMiddlewares({
             ...options,
@@ -6178,11 +5901,268 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         });
         return middlewares.push(...after), {
             close: async ()=>{
-                await (null == compileMiddlewareAPI ? void 0 : compileMiddlewareAPI.close());
+                await (null == compilationManager ? void 0 : compilationManager.close());
             },
             onUpgrade,
             middlewares
         };
+    }, external_node_vm_namespaceObject = require("node:vm");
+    var external_node_vm_default = __webpack_require__.n(external_node_vm_namespaceObject);
+    let SYNTHETIC_MODULES_STORE = '__SYNTHETIC_MODULES_STORE', asModule = async (something, context, unlinked)=>{
+        if (something instanceof external_node_vm_default().Module) return something;
+        context[SYNTHETIC_MODULES_STORE] = context[SYNTHETIC_MODULES_STORE] || [];
+        let i = context[SYNTHETIC_MODULES_STORE].length;
+        context[SYNTHETIC_MODULES_STORE].push(something);
+        let code = [
+            ...new Set([
+                'default',
+                ...Object.keys(something)
+            ])
+        ].map((name)=>`const _${name} = ${SYNTHETIC_MODULES_STORE}[${i}]${'default' === name ? '' : `[${JSON.stringify(name)}]`}; export { _${name} as ${name}};`).join('\n'), m = new (external_node_vm_default()).SourceTextModule(code, {
+            context
+        });
+        return unlinked || (await m.link(()=>{}), m.instantiate && m.instantiate(), await m.evaluate()), m;
+    };
+    function basic_define_property(obj, key, value) {
+        return key in obj ? Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : obj[key] = value, obj;
+    }
+    let isRelativePath = (p)=>/^\.\.?\//.test(p), getSubPath = (p)=>{
+        let lastSlash = p.lastIndexOf('/'), firstSlash = p.indexOf('/');
+        if (-1 !== lastSlash && firstSlash !== lastSlash) {
+            if (-1 !== firstSlash) {
+                let next = p.indexOf('/', firstSlash + 1), dir = p.slice(firstSlash + 1, next);
+                for(; '.' === dir;)firstSlash = next, next = p.indexOf('/', firstSlash + 1), dir = p.slice(firstSlash + 1, next);
+            }
+            return p.slice(firstSlash + 1, lastSlash + 1);
+        }
+        return '';
+    };
+    class BasicRunner {
+        run(file) {
+            this.globalContext || (this.globalContext = this.createGlobalContext()), this.baseModuleScope = this.createBaseModuleScope(), this.createRunner();
+            let res = this.getRequire()(this._options.dist, file.startsWith('./') ? file : `./${file}`);
+            return 'object' == typeof res && 'then' in res ? res : Promise.resolve(res);
+        }
+        getRequire() {
+            let entryRequire = this.requirers.get('entry');
+            return (currentDirectory, modulePath, context = {})=>entryRequire(currentDirectory, Array.isArray(modulePath) ? modulePath : modulePath.split('?')[0], context);
+        }
+        getFile(modulePath, currentDirectory) {
+            if (Array.isArray(modulePath)) return {
+                path: external_node_path_default().join(currentDirectory, '.array-require.js'),
+                content: `module.exports = (${modulePath.map((arg)=>`require(${JSON.stringify(`./${arg}`)})`).join(', ')});`,
+                subPath: ''
+            };
+            let joinedPath = isRelativePath(modulePath) ? external_node_path_default().join(currentDirectory, modulePath) : modulePath;
+            return this._options.isBundleOutput(joinedPath) ? {
+                path: joinedPath,
+                content: this._options.readFileSync(joinedPath),
+                subPath: getSubPath(modulePath)
+            } : null;
+        }
+        preExecute(_code, _file) {}
+        postExecute(_m, _file) {}
+        createRunner() {
+            this.requirers.set('entry', (_currentDirectory, _modulePath, _context = {})=>{
+                throw Error('[rsbuild:runner] Not implement');
+            });
+        }
+        constructor(_options){
+            basic_define_property(this, "_options", void 0), basic_define_property(this, "globalContext", void 0), basic_define_property(this, "baseModuleScope", void 0), basic_define_property(this, "requirers", void 0), this._options = _options, this.globalContext = null, this.baseModuleScope = null, this.requirers = new Map();
+        }
+    }
+    let cjs_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__), cjs_define = (...args)=>{
+        args.pop()();
+    };
+    class CommonJsRunner extends BasicRunner {
+        createGlobalContext() {
+            return {
+                console: console,
+                setTimeout: (cb, ms, ...args)=>{
+                    let timeout = setTimeout(cb, ms, ...args);
+                    return timeout.unref(), timeout;
+                },
+                clearTimeout: clearTimeout,
+                queueMicrotask
+            };
+        }
+        createBaseModuleScope() {
+            return {
+                console: this.globalContext.console,
+                setTimeout: this.globalContext.setTimeout,
+                clearTimeout: this.globalContext.clearTimeout,
+                nsObj: (m)=>(Object.defineProperty(m, Symbol.toStringTag, {
+                        value: 'Module'
+                    }), m),
+                queueMicrotask
+            };
+        }
+        createModuleScope(requireFn, m, file) {
+            return {
+                ...this.baseModuleScope,
+                require: requireFn.bind(null, external_node_path_default().dirname(file.path)),
+                module: m,
+                exports: m.exports,
+                __dirname: external_node_path_default().dirname(file.path),
+                __filename: file.path,
+                define: cjs_define
+            };
+        }
+        createRunner() {
+            this.requirers.set('miss', this.createMissRequirer()), this.requirers.set('entry', this.createCjsRequirer());
+        }
+        createMissRequirer() {
+            return (_currentDirectory, modulePath, _context = {})=>{
+                let resolvedPath = cjs_require.resolve(modulePath, {
+                    paths: [
+                        _currentDirectory
+                    ]
+                });
+                return cjs_require(resolvedPath.startsWith('node:') ? resolvedPath.slice(5) : resolvedPath);
+            };
+        }
+        createCjsRequirer() {
+            let requireCache = Object.create(null);
+            return (currentDirectory, modulePath, context = {})=>{
+                let file = context.file || this.getFile(modulePath, currentDirectory);
+                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
+                if (file.path in requireCache) return requireCache[file.path].exports;
+                let m = {
+                    exports: {}
+                };
+                requireCache[file.path] = m;
+                let currentModuleScope = this.createModuleScope(this.getRequire(), m, file), args = Object.keys(currentModuleScope), argValues = args.map((arg)=>currentModuleScope[arg]), code = `(function(${args.join(', ')}) {
+        ${file.content}
+      })`;
+                this.preExecute(code, file);
+                let dynamicImport = Function('specifier', 'return import(specifier)');
+                return external_node_vm_default().runInThisContext(code, {
+                    filename: file.path,
+                    importModuleDynamically: async (specifier)=>await dynamicImport(specifier)
+                }).call(m.exports, ...argValues), this.postExecute(m, file), m.exports;
+            };
+        }
+    }
+    var type_EsmMode = function(EsmMode) {
+        return EsmMode[EsmMode.Unknown = 0] = "Unknown", EsmMode[EsmMode.Evaluated = 1] = "Evaluated", EsmMode[EsmMode.Unlinked = 2] = "Unlinked", EsmMode;
+    }({});
+    class EsmRunner extends CommonJsRunner {
+        createRunner() {
+            var _this__options_compilerOptions_experiments;
+            super.createRunner(), this.requirers.set('cjs', this.getRequire()), this.requirers.set('esm', this.createEsmRequirer());
+            let outputModule = null === (_this__options_compilerOptions_experiments = this._options.compilerOptions.experiments) || void 0 === _this__options_compilerOptions_experiments ? void 0 : _this__options_compilerOptions_experiments.outputModule;
+            this.requirers.set('entry', (currentDirectory, modulePath, context)=>{
+                let file = this.getFile(modulePath, currentDirectory);
+                return file ? outputModule && !file.path.endsWith('.cjs') ? this.requirers.get('esm')(currentDirectory, modulePath, {
+                    ...context,
+                    file
+                }) : this.requirers.get('cjs')(currentDirectory, modulePath, {
+                    ...context,
+                    file
+                }) : this.requirers.get('miss')(currentDirectory, modulePath);
+            });
+        }
+        createEsmRequirer() {
+            let esmContext = external_node_vm_default().createContext(this.baseModuleScope, {
+                name: 'context for esm'
+            }), esmCache = new Map(), esmIdentifier = this._options.name;
+            return (currentDirectory, modulePath, context = {})=>{
+                if (!external_node_vm_default().SourceTextModule) throw Error('[rsbuild:runner] Running ESM bundle needs add Node.js option "--experimental-vm-modules".');
+                let _require = this.getRequire(), file = context.file || this.getFile(modulePath, currentDirectory);
+                if (!file) return this.requirers.get('miss')(currentDirectory, modulePath);
+                let esm = esmCache.get(file.path);
+                return (esm || (esm = new (external_node_vm_default()).SourceTextModule(file.content, {
+                    identifier: `${esmIdentifier}-${file.path}`,
+                    url: `${(0, external_node_url_namespaceObject.pathToFileURL)(file.path).href}?${esmIdentifier}`,
+                    context: esmContext,
+                    initializeImportMeta: (meta, _)=>{
+                        meta.url = (0, external_node_url_namespaceObject.pathToFileURL)(file.path).href;
+                    },
+                    importModuleDynamically: async (specifier, module)=>{
+                        let result = await _require(external_node_path_default().dirname(file.path), specifier, {
+                            esmMode: type_EsmMode.Evaluated
+                        });
+                        return await asModule(result, module.context);
+                    }
+                }), esmCache.set(file.path, esm)), context.esmMode === type_EsmMode.Unlinked) ? esm : (async ()=>{
+                    if (await esm.link(async (specifier, referencingModule)=>await asModule(await _require(external_node_path_default().dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : (0, external_node_url_namespaceObject.fileURLToPath)(referencingModule.url)), specifier, {
+                            esmMode: type_EsmMode.Unlinked
+                        }), referencingModule.context, !0)), esm.instantiate && esm.instantiate(), await esm.evaluate(), context.esmMode === type_EsmMode.Evaluated) return esm;
+                    let ns = esm.namespace;
+                    return ns.default && ns.default instanceof Promise ? ns.default : ns;
+                })();
+            };
+        }
+    }
+    class BasicRunnerFactory {
+        create(options) {
+            return this.createRunner(options);
+        }
+        createRunner(options) {
+            let runnerOptions = {
+                name: this.name,
+                ...options
+            }, { compilerOptions } = options;
+            if ('web' === compilerOptions.target || 'webworker' === compilerOptions.target) throw Error(`[rsbuild:runner] Not support run "${compilerOptions.target}" resource in Rsbuild server`);
+            return new EsmRunner(runnerOptions);
+        }
+        constructor(name){
+            !function(obj, key, value) {
+                key in obj ? Object.defineProperty(obj, key, {
+                    value: value,
+                    enumerable: !0,
+                    configurable: !0,
+                    writable: !0
+                }) : obj[key] = value;
+            }(this, "name", void 0), this.name = name;
+        }
+    }
+    let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunnerFactory(bundlePath).create(runnerFactoryOptions).run(bundlePath), loadBundle = async (stats, entryName, utils)=>{
+        let { chunks, entrypoints, outputPath } = stats.toJson({
+            all: !1,
+            chunks: !0,
+            entrypoints: !0,
+            outputPath: !0
+        });
+        if (!(null == entrypoints ? void 0 : entrypoints[entryName])) throw Error(`[rsbuild:loadBundle] Can't find entry: "${entryName}"`);
+        let { chunks: entryChunks = [] } = entrypoints[entryName], files = entryChunks.reduce((prev, entryChunkName)=>{
+            let chunk = null == chunks ? void 0 : chunks.find((chunk)=>{
+                var _chunk_names;
+                return chunk.entry && (null === (_chunk_names = chunk.names) || void 0 === _chunk_names ? void 0 : _chunk_names.includes(String(entryChunkName)));
+            });
+            return (null == chunk ? void 0 : chunk.files) ? prev.concat(chunk.files.filter((file)=>!file.endsWith('.css'))) : prev;
+        }, []);
+        if (0 === files.length) throw Error(`[rsbuild:loadBundle] Failed to get bundle by entryName: "${entryName}"`);
+        if (files.length > 1) throw Error(`[rsbuild:loadBundle] Only support load single entry chunk, but got ${files.length}: ${files.join(',')}`);
+        let allChunkFiles = (null == chunks ? void 0 : chunks.flatMap((c)=>c.files).map((file)=>(0, external_node_path_namespaceObject.join)(outputPath, file))) || [];
+        return await runner_run({
+            bundlePath: files[0],
+            dist: outputPath,
+            compilerOptions: stats.compilation.options,
+            readFileSync: utils.readFileSync,
+            isBundleOutput: (modulePath)=>allChunkFiles.includes(modulePath)
+        });
+    }, getTransformedHtml = async (entryName, utils)=>{
+        let { htmlPaths, distPath } = utils.environment, htmlPath = htmlPaths[entryName];
+        if (!htmlPath) throw Error(`[rsbuild:getTransformedHtml] Failed to get HTML file by entryName: "${entryName}"`);
+        let fileName = (0, external_node_path_namespaceObject.join)(distPath, htmlPath);
+        return utils.readFileSync(fileName);
+    }, createCacheableFunction = (getter)=>{
+        let cache = new WeakMap();
+        return async (stats, entryName, utils)=>{
+            let cachedEntries = cache.get(stats);
+            if (null == cachedEntries ? void 0 : cachedEntries[entryName]) return cachedEntries[entryName];
+            let res = await getter(stats, entryName, utils);
+            return cache.set(stats, {
+                ...cachedEntries || {},
+                [entryName]: res
+            }), res;
+        };
     }, cleanupCallbacks = new Set(), handleTermination = async (_, exitCode)=>{
         try {
             await Promise.all([
@@ -6222,14 +6202,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         rslog_index_js_namespaceObject.logger.debug('create dev server');
         let { port, host, https, portTip } = await getServerConfig({
             config
-        }), { middlewareMode } = config.server, devConfig = devServer_formatDevConfig(config.dev, port), routes = getRoutes(options.context), root = options.context.rootPath;
-        options.context.devServer = {
+        }), { middlewareMode } = config.server, { context } = options, devConfig = devServer_formatDevConfig(config.dev, port), routes = getRoutes(context), root = context.rootPath;
+        context.devServer = {
             hostname: host,
             port,
             https
         };
-        let outputFileSystem = external_node_fs_default(), waitFirstCompileDone = runCompile ? new Promise((resolve)=>{
-            options.context.hooks.onDevCompileDone.tap(({ stats, isFirstCompile })=>{
+        let waitFirstCompileDone = runCompile ? new Promise((resolve)=>{
+            context.hooks.onDevCompileDone.tap(({ stats, isFirstCompile })=>{
                 lastStats = 'stats' in stats ? stats.stats : [
                     stats
                 ], isFirstCompile && resolve();
@@ -6239,7 +6219,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             if (!compiler) throw Error('[rsbuild:server] Failed to get compiler instance.');
             let publicPaths = helpers_isMultiCompiler(compiler) ? compiler.compilers.map(getPublicPathFromCompiler) : [
                 getPublicPathFromCompiler(compiler)
-            ], compilerDevMiddleware = new CompilerDevMiddleware({
+            ], compilationManager = new CompilationManager({
                 dev: devConfig,
                 server: {
                     ...config.server,
@@ -6247,14 +6227,9 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 },
                 publicPaths: publicPaths,
                 compiler,
-                environments: options.context.environments
+                environments: context.environments
             });
-            return await compilerDevMiddleware.init(), outputFileSystem = (helpers_isMultiCompiler(compiler) ? compiler.compilers[0].outputFileSystem : compiler.outputFileSystem) || external_node_fs_default(), {
-                middleware: compilerDevMiddleware.middleware,
-                sockWrite: (...args)=>compilerDevMiddleware.sockWrite(...args),
-                onUpgrade: (...args)=>compilerDevMiddleware.upgrade(...args),
-                close: ()=>null == compilerDevMiddleware ? void 0 : compilerDevMiddleware.close()
-            };
+            return await compilationManager.init(), compilationManager;
         }, protocol = https ? 'https' : 'http', urls = getAddressUrls({
             protocol,
             port,
@@ -6273,7 +6248,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 config,
                 clearCache: !0
             }), cleanupGracefulShutdown = middlewareMode ? null : setupGracefulShutdown(), closeServer = async ()=>{
-            removeCleanup(closeServer), null == cleanupGracefulShutdown || cleanupGracefulShutdown(), await options.context.hooks.onCloseDevServer.callBatch(), await Promise.all([
+            removeCleanup(closeServer), null == cleanupGracefulShutdown || cleanupGracefulShutdown(), await context.hooks.onCloseDevServer.callBatch(), await Promise.all([
                 null == devMiddlewares ? void 0 : devMiddlewares.close(),
                 null == fileWatcher ? void 0 : fileWatcher.close()
             ]);
@@ -6291,24 +6266,30 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     help: shortcutsOptions.help,
                     customShortcuts: shortcutsOptions.custom
                 });
-                options.context.hooks.onCloseDevServer.tap(cleanup);
+                context.hooks.onCloseDevServer.tap(cleanup);
             }
             !getPortSilently && portTip && rslog_index_js_namespaceObject.logger.info(portTip);
-        }, readFileSync = (fileName)=>'readFileSync' in outputFileSystem ? outputFileSystem.readFileSync(fileName, 'utf-8') : external_node_fs_default().readFileSync(fileName, 'utf-8'), cacheableLoadBundle = createCacheableFunction(loadBundle), cacheableTransformedHtml = createCacheableFunction((_stats, entryName, utils)=>getTransformedHtml(entryName, utils)), environmentAPI = Object.fromEntries(Object.entries(options.context.environments).map(([name, environment])=>[
+        }, cacheableLoadBundle = createCacheableFunction(loadBundle), cacheableTransformedHtml = createCacheableFunction((_stats, entryName, utils)=>getTransformedHtml(entryName, utils)), environmentAPI = Object.fromEntries(Object.entries(context.environments).map(([name, environment])=>[
                 name,
                 {
                     getStats: async ()=>{
-                        if (!runCompile) throw Error('[rsbuild:server] Can not get stats info when "runCompile" is false');
+                        if (!compilationManager) throw Error('[rsbuild:server] Can not call `getStats` when `runCompile` is false');
                         return await waitFirstCompileDone, lastStats[environment.index];
                     },
-                    loadBundle: async (entryName)=>(await waitFirstCompileDone, cacheableLoadBundle(lastStats[environment.index], entryName, {
-                            readFileSync,
+                    loadBundle: async (entryName)=>{
+                        if (!compilationManager) throw Error('[rsbuild:server] Can not call `loadBundle` when `runCompile` is false');
+                        return await waitFirstCompileDone, cacheableLoadBundle(lastStats[environment.index], entryName, {
+                            readFileSync: compilationManager.readFileSync,
                             environment
-                        })),
-                    getTransformedHtml: async (entryName)=>(await waitFirstCompileDone, cacheableTransformedHtml(lastStats[environment.index], entryName, {
-                            readFileSync,
+                        });
+                    },
+                    getTransformedHtml: async (entryName)=>{
+                        if (!compilationManager) throw Error('[rsbuild:server] Can not call `getTransformedHtml` when `runCompile` is false');
+                        return await waitFirstCompileDone, cacheableTransformedHtml(lastStats[environment.index], entryName, {
+                            readFileSync: compilationManager.readFileSync,
                             environment
-                        }))
+                        });
+                    }
                 }
             ])), { default: connect } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/connect/index.js")), middlewares = connect(), httpServer = middlewareMode ? null : await createHttpServer({
             serverConfig: config.server,
@@ -6321,7 +6302,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             listen: async ()=>{
                 if (!httpServer) throw Error('[rsbuild:server] Can not listen dev server as `server.middlewareMode` is enabled.');
                 let serverTerminator = getServerTerminator(httpServer);
-                return rslog_index_js_namespaceObject.logger.debug('listen dev server'), options.context.hooks.onCloseDevServer.tap(serverTerminator), new Promise((resolve)=>{
+                return rslog_index_js_namespaceObject.logger.debug('listen dev server'), context.hooks.onCloseDevServer.tap(serverTerminator), new Promise((resolve)=>{
                     httpServer.listen({
                         host,
                         port
@@ -6338,10 +6319,10 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 });
             },
             afterListen: async ()=>{
-                await options.context.hooks.onAfterStartDevServer.callBatch({
+                await context.hooks.onAfterStartDevServer.callBatch({
                     port,
                     routes,
-                    environments: options.context.environments
+                    environments: context.environments
                 });
             },
             connectWebSocket: ({ server })=>{
@@ -6350,27 +6331,24 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             close: closeServer,
             printUrls,
             open: openPage
-        }, postCallbacks = (await options.context.hooks.onBeforeStartDevServer.callBatch({
+        }, postCallbacks = (await context.hooks.onBeforeStartDevServer.callBatch({
             server: devServerAPI,
-            environments: options.context.environments
+            environments: context.environments
         })).filter((item)=>'function' == typeof item);
-        runCompile ? options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
-        let compileMiddlewareAPI = runCompile ? await startCompile() : void 0;
+        runCompile ? context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
+        let compilationManager = runCompile ? await startCompile() : void 0;
         for (let item of (fileWatcher = await setupWatchFiles({
             dev: devConfig,
             server: config.server,
-            compileMiddlewareAPI,
+            compilationManager,
             root
-        }), (devMiddlewares = await getMiddlewares({
+        }), (devMiddlewares = await getDevMiddlewares({
             pwd: root,
-            compileMiddlewareAPI,
+            compilationManager,
             dev: devConfig,
+            context,
             server: config.server,
             environments: environmentAPI,
-            output: {
-                distPath: options.context.distPath || ROOT_DIST_DIR
-            },
-            outputFileSystem,
             postCallbacks
         })).middlewares))Array.isArray(item) ? middlewares.use(...item) : middlewares.use(item);
         return rslog_index_js_namespaceObject.logger.debug('create dev server done'), devServerAPI;
@@ -6742,9 +6720,9 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 setup (api) {
                     'webpack' !== api.context.bundlerType && (api.modifyRsbuildConfig((config)=>{
                         let { moduleFederation } = config;
-                        if ((null == moduleFederation ? void 0 : moduleFederation.options) && moduleFederation.options.exposes) {
+                        if (api.isPluginExists('rsbuild:module-federation-enhanced') && (config.server ||= {}, config.server.cors ||= !0), (null == moduleFederation ? void 0 : moduleFederation.options) && moduleFederation.options.exposes) {
                             var _config_server, _config_dev_client, _originalConfig_dev, _config_server1;
-                            config.dev ||= {}, (null === (_config_server = config.server) || void 0 === _config_server ? void 0 : _config_server.port) && !(null === (_config_dev_client = config.dev.client) || void 0 === _config_dev_client ? void 0 : _config_dev_client.port) && (config.dev.client ||= {}, config.dev.client.port = config.server.port), (null === (_originalConfig_dev = api.getRsbuildConfig('original').dev) || void 0 === _originalConfig_dev ? void 0 : _originalConfig_dev.assetPrefix) === void 0 && config.dev.assetPrefix === (null === (_config_server1 = config.server) || void 0 === _config_server1 ? void 0 : _config_server1.base) && (config.dev.assetPrefix = !0);
+                            config.dev ||= {}, config.server ||= {}, config.server.cors ||= !0, (null === (_config_server = config.server) || void 0 === _config_server ? void 0 : _config_server.port) && !(null === (_config_dev_client = config.dev.client) || void 0 === _config_dev_client ? void 0 : _config_dev_client.port) && (config.dev.client ||= {}, config.dev.client.port = config.server.port), (null === (_originalConfig_dev = api.getRsbuildConfig('original').dev) || void 0 === _originalConfig_dev ? void 0 : _originalConfig_dev.assetPrefix) === void 0 && config.dev.assetPrefix === (null === (_config_server1 = config.server) || void 0 === _config_server1 ? void 0 : _config_server1.base) && (config.dev.assetPrefix = !0);
                         }
                     }), api.modifyEnvironmentConfig((config)=>{
                         var _config_moduleFederation, _config_performance_chunkSplit, _config_performance;
@@ -6769,7 +6747,6 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 }
             },
             pluginRspackProfile(),
-            pluginLazyCompilation(),
             pluginSri(),
             pluginNonce()
         ]);
@@ -7445,11 +7422,11 @@ ${section.body}` : section.body).join("\n\n"));
             }
         }(), process.title = 'rsbuild-node';
         let { npm_execpath } = process.env;
-        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), rslog_index_js_namespaceObject.logger.greet(`  Rsbuild v1.3.0-beta.1\n`);
+        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), rslog_index_js_namespaceObject.logger.greet(`  Rsbuild v1.3.0-beta.3\n`);
         try {
             !function() {
                 let cli = cac_dist('rsbuild');
-                cli.help(), cli.version("1.3.0-beta.1"), applyCommonOptions(cli);
+                cli.help(), cli.version("1.3.0-beta.3"), applyCommonOptions(cli);
                 let devCommand = cli.command('', 'starting the dev server').alias('dev'), buildCommand = cli.command('build', 'build the app for production'), previewCommand = cli.command('preview', 'preview the production build locally'), inspectCommand = cli.command('inspect', 'inspect the Rspack and Rsbuild configs');
                 applyServerOptions(devCommand), applyServerOptions(previewCommand), devCommand.action(async (options)=>{
                     try {
@@ -7500,7 +7477,7 @@ ${section.body}` : section.body).join("\n\n"));
             rslog_index_js_namespaceObject.logger.error('Failed to start Rsbuild CLI.'), rslog_index_js_namespaceObject.logger.error(err);
         }
     }
-    let src_rslib_entry_version = "1.3.0-beta.1";
+    let src_rslib_entry_version = "1.3.0-beta.3";
 })();
 var __webpack_export_target__ = exports;
 for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];