@rsbuild/core 1.2.7 → 1.2.9

package/dist/index.cjs

@@ -606,38 +606,39 @@ var __webpack_exports__ = {};
         return !verbose && message.includes(innerError) && (message = message.split(innerError)[0]), (message = (message = hintNodePolyfill(message = function(message) {
             let hint = 'You may need an appropriate loader to handle this file type.';
             if (-1 === message.indexOf(hint)) return message;
+            let createPluginHint = (packageName, keyword)=>`To enable support for ${keyword}, use "${index_js_default().yellow(`@rsbuild/plugin-${packageName}`)}" ${index_js_default().dim(`(https://www.npmjs.com/package/@rsbuild/plugin-${packageName})`)}.`;
             for (let plugin of [
                 {
                     test: /File: .+\.s(c|a)ss/,
-                    hint: `To enable support for Sass, use "${index_js_default().yellow('@rsbuild/plugin-sass')}".`
+                    hint: createPluginHint('sass', 'Sass')
                 },
                 {
                     test: /File: .+\.less/,
-                    hint: `To enable support for Less, use "${index_js_default().yellow('@rsbuild/plugin-less')}".`
+                    hint: createPluginHint('less', 'Less')
                 },
                 {
                     test: /File: .+\.styl(us)?/,
-                    hint: `To enable support for Stylus, use "${index_js_default().yellow('@rsbuild/plugin-stylus')}".`
+                    hint: createPluginHint('stylus', 'Stylus')
                 },
                 {
                     test: /File: .+\.vue?/,
-                    hint: `To enable support for Vue, use "${index_js_default().yellow('@rsbuild/plugin-vue')}".`
+                    hint: createPluginHint('vue', 'Vue')
                 },
                 {
                     test: /File: .+\.svelte?/,
-                    hint: `To enable support for Svelte, use "${index_js_default().yellow('@rsbuild/plugin-svelte')}".`
+                    hint: createPluginHint('svelte', 'Svelte')
                 },
                 {
                     test: /File: .+\.mdx/,
-                    hint: `To enable support for MDX, use "${index_js_default().yellow('@rsbuild/plugin-mdx')}".`
+                    hint: createPluginHint('mdx', 'MDX')
                 },
                 {
                     test: /File: .+\.toml/,
-                    hint: `To enable support for TOML, use "${index_js_default().yellow('@rsbuild/plugin-toml')}".`
+                    hint: createPluginHint('toml', 'TOML')
                 },
                 {
                     test: /File: .+\.yaml/,
-                    hint: `To enable support for YAML, use "${index_js_default().yellow('@rsbuild/plugin-yaml')}".`
+                    hint: createPluginHint('yaml', 'YAML')
                 }
             ])if (plugin.test.test(message)) return message.replace(hint, plugin.hint);
             return message;
@@ -1434,7 +1435,7 @@ var __webpack_exports__ = {};
             tap: (handler)=>tapEnvironment({
                     handler
                 }),
-            callInEnvironment: async ({ environment, args: params })=>{
+            callChain: async ({ environment, args: params })=>{
                 for (let callback of [
                     ...preGroup,
                     ...defaultGroup,
@@ -1445,6 +1446,19 @@ var __webpack_exports__ = {};
                     void 0 !== result && (params[0] = result);
                 }
                 return params;
+            },
+            callBatch: async ({ environment, args: params })=>{
+                let results = [];
+                for (let callback of [
+                    ...preGroup,
+                    ...defaultGroup,
+                    ...postGroup
+                ]){
+                    if (callback.environment && environment && !isPluginMatchEnvironment(callback.environment, environment)) continue;
+                    let result = await callback.handler(...params);
+                    results.push(result);
+                }
+                return results;
             }
         };
     }
@@ -1454,7 +1468,7 @@ var __webpack_exports__ = {};
             tap: (cb)=>{
                 isFunction(cb) ? defaultGroup.push(cb) : 'pre' === cb.order ? preGroup.push(cb.handler) : 'post' === cb.order ? postGroup.push(cb.handler) : defaultGroup.push(cb.handler);
             },
-            call: async (...params)=>{
+            callChain: async (...params)=>{
                 for (let callback of [
                     ...preGroup,
                     ...defaultGroup,
@@ -1464,6 +1478,18 @@ var __webpack_exports__ = {};
                     void 0 !== result && (params[0] = result);
                 }
                 return params;
+            },
+            callBatch: async (...params)=>{
+                let results = [];
+                for (let callback of [
+                    ...preGroup,
+                    ...defaultGroup,
+                    ...postGroup
+                ]){
+                    let result = await callback(...params);
+                    results.push(result);
+                }
+                return results;
             }
         };
     }
@@ -1501,7 +1527,7 @@ var __webpack_exports__ = {};
         });
     }, registerBuildHook = ({ context, isWatch, compiler, bundlerConfigs, MultiStatsCtor })=>{
         let isFirstCompile = !0, environmentList = Object.values(context.environments).reduce((prev, curr)=>(prev[curr.index] = curr, prev), []), onDone = async (stats)=>{
-            let p = context.hooks.onAfterBuild.call({
+            let p = context.hooks.onAfterBuild.callBatch({
                 isFirstCompile,
                 stats,
                 environments: context.environments,
@@ -1509,7 +1535,7 @@ var __webpack_exports__ = {};
             });
             isFirstCompile = !1, await p;
         }, onEnvironmentDone = async (buildIndex, stats)=>{
-            await context.hooks.onAfterEnvironmentCompile.callInEnvironment({
+            await context.hooks.onAfterEnvironmentCompile.callBatch({
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
@@ -1523,13 +1549,13 @@ var __webpack_exports__ = {};
         };
         onBeforeCompile({
             compiler,
-            beforeCompile: async ()=>await context.hooks.onBeforeBuild.call({
+            beforeCompile: async ()=>await context.hooks.onBeforeBuild.callBatch({
                     bundlerConfigs,
                     environments: context.environments,
                     isWatch,
                     isFirstCompile
                 }),
-            beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callInEnvironment({
+            beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callBatch({
                     environment: environmentList[buildIndex].name,
                     args: [
                         {
@@ -1549,14 +1575,14 @@ var __webpack_exports__ = {};
         });
     }, registerDevHook = ({ context, compiler, bundlerConfigs, MultiStatsCtor })=>{
         let isFirstCompile = !0, environmentList = Object.values(context.environments).reduce((prev, curr)=>(prev[curr.index] = curr, prev), []), onDone = async (stats)=>{
-            let p = context.hooks.onDevCompileDone.call({
+            let p = context.hooks.onDevCompileDone.callBatch({
                 isFirstCompile,
                 stats,
                 environments: context.environments
             });
             isFirstCompile = !1, await p;
         }, onEnvironmentDone = async (buildIndex, stats)=>{
-            await context.hooks.onAfterEnvironmentCompile.callInEnvironment({
+            await context.hooks.onAfterEnvironmentCompile.callBatch({
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
@@ -1570,7 +1596,7 @@ var __webpack_exports__ = {};
         };
         onBeforeCompile({
             compiler,
-            beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callInEnvironment({
+            beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callBatch({
                     environment: environmentList[buildIndex].name,
                     args: [
                         {
@@ -1708,7 +1734,7 @@ var __webpack_exports__ = {};
     async function createContext(options, userConfig, bundlerType) {
         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.2.7",
+            version: "1.2.9",
             rootPath,
             distPath: '',
             cachePath,
@@ -1841,7 +1867,7 @@ var __webpack_exports__ = {};
     async function modifyBundlerChain(context, utils) {
         var _utils_environment_config_tools;
         rslog_index_js_namespaceObject.logger.debug('modify bundler chain');
-        let bundlerChain = new (rspack_chain_index_js_default())(), [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.callInEnvironment({
+        let bundlerChain = new (rspack_chain_index_js_default())(), [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.callChain({
             environment: utils.environment.name,
             args: [
                 bundlerChain,
@@ -2036,7 +2062,7 @@ var __webpack_exports__ = {};
             recursive: !0
         }), await external_node_fs_default().promises.writeFile(configFile, JSON.stringify(buildDependencies));
     }
-    async function getBuildDependencies(context, config, environmentContext) {
+    async function getBuildDependencies(context, config, environmentContext, userBuildDependencies) {
         var _config__privateMeta;
         let rootPackageJson = (0, external_node_path_namespaceObject.join)(context.rootPath, 'package.json'), browserslistConfig = (0, external_node_path_namespaceObject.join)(context.rootPath, '.browserslistrc'), buildDependencies = {};
         await isFileExists(rootPackageJson) && (buildDependencies.packageJson = [
@@ -2058,7 +2084,10 @@ var __webpack_exports__ = {};
         ].map((ext)=>(0, external_node_path_namespaceObject.join)(context.rootPath, `tailwind.config.${ext}`)));
         return tailwindConfig && (buildDependencies.tailwindcss = [
             tailwindConfig
-        ]), buildDependencies;
+        ]), {
+            ...buildDependencies,
+            ...userBuildDependencies
+        };
     }
     let pluginCache = ()=>({
             name: 'rsbuild:cache',
@@ -2071,7 +2100,9 @@ var __webpack_exports__ = {};
                     cacheEnabled = !0;
                     let { context } = api, cacheConfig = 'boolean' == typeof buildCache ? {} : buildCache, cacheDirectory = function({ cacheDirectory }, context) {
                         return cacheDirectory ? (0, external_node_path_namespaceObject.isAbsolute)(cacheDirectory) ? cacheDirectory : (0, external_node_path_namespaceObject.join)(context.rootPath, cacheDirectory) : (0, external_node_path_namespaceObject.join)(context.cachePath, context.bundlerType);
-                    }(cacheConfig, context), buildDependencies = await getBuildDependencies(context, config, environment);
+                    }(cacheConfig, context), buildDependencies = await getBuildDependencies(context, config, environment, cacheConfig.buildDependencies ? {
+                        userBuildDependencies: cacheConfig.buildDependencies
+                    } : {});
                     'webpack' === bundlerType && await validateWebpackCache(cacheDirectory, buildDependencies);
                     let cacheVersion = Array.isArray(cacheConfig.cacheDigest) && cacheConfig.cacheDigest.length ? `${environment.name}-${env}-${digest = cacheConfig.cacheDigest, external_node_crypto_default().createHash('md5').update(JSON.stringify(digest)).digest('hex').slice(0, 8)}` : `${environment.name}-${env}`;
                     'rspack' === bundlerType ? (chain.cache(!0), chain.experiments({
@@ -2365,7 +2396,7 @@ var __webpack_exports__ = {};
     async function gzipSize(input) {
         return (await fileSize_gzip(input)).length;
     }
-    let excludeAsset = (asset)=>/\.(?:map|LICENSE\.txt)$/.test(asset.name), getAssetColor = (size)=>size > 300000 ? index_js_default().red : size > 100000 ? index_js_default().yellow : index_js_default().green, calcFileSize = (len)=>{
+    let EXCLUDE_ASSET_REGEX = /\.(?:map|LICENSE\.txt|d\.ts)$/, excludeAsset = (asset)=>EXCLUDE_ASSET_REGEX.test(asset.name), getAssetColor = (size)=>size > 300000 ? index_js_default().red : size > 100000 ? index_js_default().yellow : index_js_default().green, calcFileSize = (len)=>{
         let val = len / 1000;
         return `${val.toFixed(val < 1 ? 2 : 1)} kB`;
     }, coloringAssetName = (assetName)=>JS_REGEX.test(assetName) ? index_js_default().cyan(assetName) : CSS_REGEX.test(assetName) ? index_js_default().yellow(assetName) : HTML_REGEX.test(assetName) ? index_js_default().green(assetName) : index_js_default().magenta(assetName), COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest)$/i, isCompressible = (assetName)=>COMPRESSIBLE_REGEX.test(assetName);
@@ -2424,7 +2455,7 @@ var __webpack_exports__ = {};
         let totalSize = 0, totalGzipSize = 0;
         for (let asset of assets){
             let { sizeLabel } = asset, { name, folder, gzipSizeLabel } = asset, fileNameLength = (folder + external_node_path_default().sep + name).length, sizeLength = sizeLabel.length;
-            if (totalSize += asset.size, asset.gzippedSize && (totalGzipSize += asset.gzippedSize), !1 !== options.detail) {
+            if (totalSize += asset.size, options.compressed && (totalGzipSize += asset.gzippedSize ?? asset.size), !1 !== options.detail) {
                 sizeLength < longestLabelLength && (sizeLabel += ' '.repeat(longestLabelLength - sizeLength));
                 let fileNameLabel = index_js_default().dim(asset.folder + external_node_path_default().sep) + coloringAssetName(asset.name);
                 fileNameLength < longestFileLength && (fileNameLabel += ' '.repeat(longestFileLength - fileNameLength));
@@ -3376,7 +3407,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 api.modifyBundlerChain(async (chain, { CHAIN_ID, target, isProd, isServer, environment })=>{
                     let { distPath, config } = environment, publicPath = function({ isProd, config, context }) {
                         var _context_devServer, _context_devServer1, _context_devServer2;
-                        let { dev, output, server } = config, publicPath = DEFAULT_ASSET_PREFIX, port = (null === (_context_devServer = context.devServer) || void 0 === _context_devServer ? void 0 : _context_devServer.port) || 3000;
+                        let { dev, output, server } = config, publicPath = DEFAULT_ASSET_PREFIX, port = (null === (_context_devServer = context.devServer) || void 0 === _context_devServer ? void 0 : _context_devServer.port) || server.port || 3000;
                         if (isProd) 'string' == typeof output.assetPrefix && (publicPath = output.assetPrefix);
                         else if ('string' == typeof dev.assetPrefix) publicPath = dev.assetPrefix;
                         else if (!0 === dev.assetPrefix) {
@@ -3549,7 +3580,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }) : obj[key] = value, obj;
     }
     let HtmlPreloadOrPrefetchPlugin_defaultOptions = {
-        type: 'async-chunks'
+        type: 'async-chunks',
+        dedupe: !0
     };
     class HtmlPreloadOrPrefetchPlugin {
         apply(compiler) {
@@ -3626,7 +3658,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     if (this.resourceHints) {
                         var resourceHints, scripts;
                         htmlPluginData.assetTags.styles = [
-                            ...(resourceHints = this.resourceHints, scripts = htmlPluginData.assetTags.scripts, resourceHints.filter((resourceHint)=>!scripts.find((script)=>script.attributes.src === resourceHint.attributes.href))),
+                            ...this.options.dedupe ? (resourceHints = this.resourceHints, scripts = htmlPluginData.assetTags.scripts, resourceHints.filter((resourceHint)=>!scripts.find((script)=>script.attributes.src === resourceHint.attributes.href))) : this.resourceHints,
                             ...htmlPluginData.assetTags.styles
                         ];
                     }
@@ -4191,7 +4223,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
     async function modifyRspackConfig(context, rspackConfig, utils) {
         var _utils_environment_config_tools;
         rslog_index_js_namespaceObject.logger.debug('modify Rspack config');
-        let [modifiedConfig] = await context.hooks.modifyRspackConfig.callInEnvironment({
+        let [modifiedConfig] = await context.hooks.modifyRspackConfig.callChain({
             environment: utils.environment.name,
             args: [
                 rspackConfig,
@@ -4269,14 +4301,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
     }
     async function modifyRsbuildConfig(context) {
         rslog_index_js_namespaceObject.logger.debug('modify Rsbuild config');
-        let [modified] = await context.hooks.modifyRsbuildConfig.call(context.config, {
+        let [modified] = await context.hooks.modifyRsbuildConfig.callChain(context.config, {
             mergeRsbuildConfig: mergeRsbuildConfig
         });
         context.config = modified, rslog_index_js_namespaceObject.logger.debug('modify Rsbuild config done');
     }
     async function modifyEnvironmentConfig(context, config, name) {
         rslog_index_js_namespaceObject.logger.debug(`modify Rsbuild environment(${name}) config`);
-        let [modified] = await context.hooks.modifyEnvironmentConfig.callInEnvironment({
+        let [modified] = await context.hooks.modifyEnvironmentConfig.callChain({
             environment: name,
             args: [
                 config,
@@ -4987,15 +5019,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 content: `module.exports = (${modulePath.map((arg)=>`require(${JSON.stringify(`./${arg}`)})`).join(', ')});`,
                 subPath: ''
             };
-            if (isRelativePath(modulePath)) {
-                let p = external_node_path_default().join(currentDirectory, modulePath);
-                return {
-                    path: p,
-                    content: this._options.readFileSync(p),
-                    subPath: getSubPath(modulePath)
-                };
-            }
-            return null;
+            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) {}
@@ -5049,7 +5078,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             this.requirers.set('miss', this.createMissRequirer()), this.requirers.set('entry', this.createCjsRequirer());
         }
         createMissRequirer() {
-            return (_currentDirectory, modulePath, _context = {})=>cjs_require(modulePath.startsWith('node:') ? modulePath.slice(5) : modulePath);
+            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);
@@ -5073,10 +5109,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
     }({});
     class EsmRunner extends CommonJsRunner {
         createRunner() {
-            super.createRunner(), this.requirers.set('cjs', this.getRequire()), this.requirers.set('esm', this.createEsmRequirer()), this.requirers.set('entry', (currentDirectory, modulePath, context)=>{
-                var _this__options_compilerOptions_experiments;
+            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 ? file.path.endsWith('.mjs') && (null === (_this__options_compilerOptions_experiments = this._options.compilerOptions.experiments) || void 0 === _this__options_compilerOptions_experiments ? void 0 : _this__options_compilerOptions_experiments.outputModule) ? this.requirers.get('esm')(currentDirectory, modulePath, {
+                return file ? outputModule && !file.path.endsWith('.cjs') ? this.requirers.get('esm')(currentDirectory, modulePath, {
                     ...context,
                     file
                 }) : this.requirers.get('cjs')(currentDirectory, modulePath, {
@@ -5118,16 +5156,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }
     }
     class BasicRunnerFactory {
-        create(compilerOptions, dist, readFileSync) {
-            return this.createRunner(compilerOptions, dist, readFileSync);
+        create(options) {
+            return this.createRunner(options);
         }
-        createRunner(compilerOptions, dist, readFileSync) {
+        createRunner(options) {
             let runnerOptions = {
                 name: this.name,
-                dist,
-                compilerOptions,
-                readFileSync
-            };
+                ...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);
         }
@@ -5142,7 +5178,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             }(this, "name", void 0), this.name = name;
         }
     }
-    let runner_run = async (bundlePath, outputPath, compilerOptions, readFileSync)=>new BasicRunnerFactory(bundlePath).create(compilerOptions, outputPath, readFileSync).run(bundlePath), loadBundle = async (stats, entryName, utils)=>{
+    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,
@@ -5159,7 +5195,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }, []);
         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(',')}`);
-        return await runner_run(files[0], outputPath, stats.compilation.options, utils.readFileSync);
+        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}"`);
@@ -5340,12 +5383,11 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 let opts = {
                     context,
                     changeOrigin: !0,
-                    logLevel: 'warn'
+                    logLevel: 'warn',
+                    logProvider: ()=>rslog_index_js_namespaceObject.logger
                 };
                 'string' == typeof options ? opts.target = options : Object.assign(opts, options), ret.push(opts);
             }
-            let handleError = (err)=>rslog_index_js_namespaceObject.logger.error(err);
-            for (let opts of ret)opts.onError ??= handleError;
             return ret;
         }(proxyOptions), proxyMiddlewares = [], middlewares = [], { createProxyMiddleware: baseMiddleware } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/http-proxy-middleware/index.js"));
         for (let opts of formattedOptions){
@@ -5374,7 +5416,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             before,
             after
         };
-    }, applyDefaultMiddlewares = async ({ middlewares, server, compileMiddlewareAPI, output, pwd, outputFileSystem, environments })=>{
+    }, applyDefaultMiddlewares = async ({ middlewares, server, compileMiddlewareAPI, output, pwd, outputFileSystem, environments, postCallbacks })=>{
         let upgradeEvents = [];
         if (server.compress && middlewares.push(gzipMiddleware()), middlewares.push((req, res, next)=>{
             var _parseUrl;
@@ -5417,6 +5459,7 @@ 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,
@@ -5470,11 +5513,11 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         return createServer(middlewares);
     }, devServer_formatDevConfig = (config, port)=>('<port>' === config.client.port && (config.client.port = String(port)), config);
     async function devServer_createDevServer(options, createCompiler, config, { compiler: customCompiler, getPortSilently, runCompile = !0 } = {}) {
-        let lastStats;
+        let lastStats, fileWatcher, devMiddlewares;
         rslog_index_js_namespaceObject.logger.debug('create dev server');
         let { port, host, https, portTip } = await getServerConfig({
             config
-        }), devConfig = devServer_formatDevConfig(config.dev, port), routes = getRoutes(options.context);
+        }), devConfig = devServer_formatDevConfig(config.dev, port), routes = getRoutes(options.context), root = options.context.rootPath;
         options.context.devServer = {
             hostname: host,
             port,
@@ -5508,11 +5551,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             protocol,
             port,
             host
-        });
-        await options.context.hooks.onBeforeStartDevServer.call({
-            environments: options.context.environments
-        });
-        let cliShortcutsEnabled = isCliShortcutsEnabled(devConfig), printUrls = ()=>printServerURLs({
+        }), cliShortcutsEnabled = isCliShortcutsEnabled(devConfig), printUrls = ()=>printServerURLs({
                 urls,
                 port,
                 routes,
@@ -5526,8 +5565,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 config,
                 clearCache: !0
             }), closeServer = async ()=>{
-            await options.context.hooks.onCloseDevServer.call(), await Promise.all([
-                devMiddlewares.close(),
+            await options.context.hooks.onCloseDevServer.callBatch(), await Promise.all([
+                null == devMiddlewares ? void 0 : devMiddlewares.close(),
                 null == fileWatcher ? void 0 : fileWatcher.close()
             ]);
         }, beforeCreateCompiler = ()=>{
@@ -5545,14 +5584,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 options.context.hooks.onCloseDevServer.tap(cleanup);
             }
             !getPortSilently && portTip && rslog_index_js_namespaceObject.logger.info(portTip);
-        };
-        runCompile ? options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
-        let compileMiddlewareAPI = runCompile ? await startCompile() : void 0, root = options.context.rootPath, fileWatcher = await setupWatchFiles({
-            dev: devConfig,
-            server: config.server,
-            compileMiddlewareAPI,
-            root
-        }), 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])=>[
+        }, 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])=>[
                 name,
                 {
                     getStats: async ()=>{
@@ -5568,34 +5600,23 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             environment
                         }))
                 }
-            ])), devMiddlewares = await getMiddlewares({
-            pwd: root,
-            compileMiddlewareAPI,
-            dev: devConfig,
-            server: config.server,
-            environments: environmentAPI,
-            output: {
-                distPath: options.context.distPath || ROOT_DIST_DIR
-            },
-            outputFileSystem
-        }), { default: connect } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/connect/index.js")), middlewares = connect();
-        for (let item of devMiddlewares.middlewares)Array.isArray(item) ? middlewares.use(...item) : middlewares.use(item);
-        let devServerAPI = {
+            ])), { default: connect } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/connect/index.js")), middlewares = connect(), httpServer = await createHttpServer({
+            serverConfig: config.server,
+            middlewares
+        }), devServerAPI = {
             port,
             middlewares,
             environments: environmentAPI,
+            httpServer,
             listen: async ()=>{
-                let httpServer = await createHttpServer({
-                    serverConfig: config.server,
-                    middlewares
-                }), serverTerminator = getServerTerminator(httpServer);
+                let serverTerminator = getServerTerminator(httpServer);
                 return rslog_index_js_namespaceObject.logger.debug('listen dev server'), options.context.hooks.onCloseDevServer.tap(serverTerminator), new Promise((resolve)=>{
                     httpServer.listen({
                         host,
                         port
                     }, async (err)=>{
                         if (err) throw err;
-                        middlewares.use(notFoundMiddleware), httpServer.on('upgrade', devMiddlewares.onUpgrade), rslog_index_js_namespaceObject.logger.debug('listen dev server done'), await devServerAPI.afterListen(), onBeforeRestartServer(devServerAPI.close), resolve({
+                        middlewares.use(notFoundMiddleware), devMiddlewares && httpServer.on('upgrade', devMiddlewares.onUpgrade), rslog_index_js_namespaceObject.logger.debug('listen dev server done'), await devServerAPI.afterListen(), onBeforeRestartServer(devServerAPI.close), resolve({
                             port,
                             urls: urls.map((item)=>item.url),
                             server: {
@@ -5606,25 +5627,47 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 });
             },
             afterListen: async ()=>{
-                await options.context.hooks.onAfterStartDevServer.call({
+                await options.context.hooks.onAfterStartDevServer.callBatch({
                     port,
                     routes,
                     environments: options.context.environments
                 });
             },
             connectWebSocket: ({ server })=>{
-                server.on('upgrade', devMiddlewares.onUpgrade);
+                devMiddlewares && server.on('upgrade', devMiddlewares.onUpgrade);
             },
             close: closeServer,
             printUrls,
             open: openPage
-        };
+        }, postCallbacks = (await options.context.hooks.onBeforeStartDevServer.callBatch({
+            server: devServerAPI,
+            environments: options.context.environments
+        })).filter((item)=>'function' == typeof item);
+        runCompile ? options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
+        let compileMiddlewareAPI = runCompile ? await startCompile() : void 0;
+        for (let item of (fileWatcher = await setupWatchFiles({
+            dev: devConfig,
+            server: config.server,
+            compileMiddlewareAPI,
+            root
+        }), (devMiddlewares = await getMiddlewares({
+            pwd: root,
+            compileMiddlewareAPI,
+            dev: devConfig,
+            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;
     }
     async function createCompiler_createCompiler(options) {
         rslog_index_js_namespaceObject.logger.debug('create compiler');
         let { context } = options, { rspackConfigs } = await initConfigs(options);
-        if (await context.hooks.onBeforeCreateCompiler.call({
+        if (await context.hooks.onBeforeCreateCompiler.callBatch({
             bundlerConfigs: rspackConfigs,
             environments: context.environments
         }), !await isSatisfyRspackVersion(core_namespaceObject.rspack.rspackVersion)) throw Error(`[rsbuild] The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${index_js_default().green(rspackMinVersion)}`);
@@ -5663,7 +5706,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             compiler,
             bundlerConfigs: rspackConfigs,
             MultiStatsCtor: core_namespaceObject.rspack.MultiStats
-        }), await context.hooks.onAfterCreateCompiler.call({
+        }), await context.hooks.onAfterCreateCompiler.callBatch({
             compiler,
             environments: context.environments
         }), rslog_index_js_namespaceObject.logger.debug('create compiler done'), {
@@ -5827,7 +5870,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             },
             serverConfig
         }, middlewares);
-        await context.hooks.onBeforeStartProdServer.call();
+        await context.hooks.onBeforeStartProdServer.callBatch();
         let httpServer = await createHttpServer({
             serverConfig,
             middlewares: server.middlewares
@@ -5838,7 +5881,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 port
             }, async ()=>{
                 let routes = getRoutes(context);
-                await context.hooks.onAfterStartProdServer.call({
+                await context.hooks.onAfterStartProdServer.callBatch({
                     port,
                     routes,
                     environments: context.environments
@@ -5897,7 +5940,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             pluginFileSize(),
             pluginCleanOutput(),
             pluginAsset(),
-            pluginHtml((environment)=>async (...args)=>(await context.hooks.modifyHTMLTags.callInEnvironment({
+            pluginHtml((environment)=>async (...args)=>(await context.hooks.modifyHTMLTags.callChain({
                         environment,
                         args
                     }))[0]),
@@ -6167,7 +6210,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     });
                 }, onExitListened = !1, onExit = (cb)=>{
                 onExitListened || (process.on('exit', ()=>{
-                    hooks.onExit.call();
+                    hooks.onExit.callBatch();
                 }), onExitListened = !0), hooks.onExit.tap(cb);
             };
             return (environment)=>({
@@ -6245,7 +6288,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 return {
                     ...buildInstance,
                     close: async ()=>{
-                        await context.hooks.onCloseBuild.call(), await buildInstance.close();
+                        await context.hooks.onCloseBuild.callBatch(), await buildInstance.close();
                     }
                 };
             },
@@ -6616,7 +6659,7 @@ ${section.body}` : section.body).join("\n\n"));
             }), actionArgs.push(options), command.commandAction.apply(this, actionArgs);
         }
     }
-    let cac_dist = (name = "")=>new CAC(name), applyCommonOptions = (cli)=>{
+    let dist = (name = "")=>new CAC(name), applyCommonOptions = (cli)=>{
         cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
             default: 'jiti'
         }).option('-r, --root <root>', 'specify the project root directory, can be an absolute path or a path relative to cwd').option('-m, --mode <mode>', 'specify the build mode, can be `development`, `production` or `none`').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
@@ -6640,12 +6683,12 @@ ${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.2.7\n`);
+            (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), rslog_index_js_namespaceObject.logger.greet(`  Rsbuild v1.2.9\n`);
         }();
         try {
             !function() {
-                let cli = cac_dist('rsbuild');
-                cli.help(), cli.version("1.2.7"), applyCommonOptions(cli);
+                let cli = dist('rsbuild');
+                cli.help(), cli.version("1.2.9"), applyCommonOptions(cli);
                 let devCommand = cli.command('dev', 'starting the dev server'), 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 {
@@ -6696,7 +6739,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.2.7";
+    let src_rslib_entry_version = "1.2.9";
 })();
 var __webpack_export_target__ = exports;
 for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];