@rsbuild/core 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/131.js

@@ -2527,8 +2527,8 @@ function initHooks() {
         onCloseDevServer: createAsyncHook(),
         onAfterStartDevServer: createAsyncHook(),
         onBeforeStartDevServer: createAsyncHook(),
-        onAfterStartProdServer: createAsyncHook(),
-        onBeforeStartProdServer: createAsyncHook(),
+        onAfterStartPreviewServer: createAsyncHook(),
+        onBeforeStartPreviewServer: createAsyncHook(),
         onAfterCreateCompiler: createAsyncHook(),
         onBeforeCreateCompiler: createAsyncHook(),
         modifyHTML: createEnvironmentAsyncHook(),
@@ -3282,8 +3282,8 @@ function initPluginAPI({ context, pluginManager }) {
             onAfterStartDevServer: hooks.onAfterStartDevServer.tap,
             onBeforeCreateCompiler: hooks.onBeforeCreateCompiler.tap,
             onBeforeStartDevServer: hooks.onBeforeStartDevServer.tap,
-            onAfterStartProdServer: hooks.onAfterStartProdServer.tap,
-            onBeforeStartProdServer: hooks.onBeforeStartProdServer.tap,
+            onAfterStartPreviewServer: hooks.onAfterStartPreviewServer.tap,
+            onBeforeStartPreviewServer: hooks.onBeforeStartPreviewServer.tap,
             modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap,
             modifyHTML: (handler)=>{
                 hooks.modifyHTML.tapEnvironment({
@@ -3399,7 +3399,7 @@ function createPublicContext(context) {
 async function createContext(options, userConfig) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, external_node_path_.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "2.0.0-beta.4",
+        version: "2.0.0-beta.6",
         rootPath,
         distPath: '',
         cachePath,
@@ -4964,16 +4964,14 @@ let getPort = async ({ host, port, strictPort, tryLimits = 20 })=>{
     if (!found) throw Error(`${color.dim('[rsbuild:server]')} Failed to find an available port after ${tryLimits + 1} attempts, starting from ${color.yellow(original)}.`);
     if (port !== original && strictPort) throw Error(`${color.dim('[rsbuild:server]')} Port ${color.yellow(original)} is occupied, please choose another one.`);
     return port;
-}, getServerConfig = async ({ config })=>{
+}, resolvePort = async (config)=>{
     let { host, port: originalPort, strictPort } = config.server, port = await getPort({
         host,
         port: originalPort,
         strictPort
-    }), https = !!config.server.https, portTip = port !== originalPort ? `port ${originalPort} is in use, ${color.yellow(`using port ${port}.`)}` : void 0;
+    }), portTip = port !== originalPort ? `port ${originalPort} is in use, ${color.yellow(`using port ${port}.`)}` : void 0;
     return {
         port,
-        host,
-        https,
         portTip
     };
 }, isLoopbackHost = (host)=>new Set([
@@ -4992,7 +4990,7 @@ let getPort = async ({ host, port, strictPort, tryLimits = 20 })=>{
     } catch  {
         return NETWORK_LABEL;
     }
-}, getAddressUrls = async ({ protocol = 'http', port, host })=>{
+}, getAddressUrls = async ({ protocol, port, host })=>{
     if (host && host !== ALL_INTERFACES_IPV4) {
         let url = concatUrl({
             port,
@@ -5106,7 +5104,7 @@ function resolveUrl(str, base) {
         throw Error(`${color.dim('[rsbuild:open]')} Invalid input: ${color.yellow(str)} is not a valid URL or pathname`);
     }
 }
-async function open_open({ https, port, routes, config, clearCache }) {
+async function open_open({ port, routes, config, protocol, clearCache }) {
     if ('true' === process.env.CSB) return;
     let { targets, before } = ((config)=>{
         let { open } = config.server;
@@ -5124,7 +5122,7 @@ async function open_open({ https, port, routes, config, clearCache }) {
         };
     })(config);
     clearCache && (openedURLs = []);
-    let urls = [], host = await getHostInUrl(config.server.host), baseUrl = `${https ? 'https' : 'http'}://${host}:${port}`;
+    let urls = [], host = await getHostInUrl(config.server.host), baseUrl = `${protocol}://${host}:${port}`;
     for (let url of (targets.length ? urls.push(...targets.map((target)=>resolveUrl(replacePortPlaceholder(target, port), baseUrl))) : routes.length ? urls.push(`${baseUrl}${routes[0].pathname}`) : urls.push(baseUrl), before && await before(), urls))openedURLs.includes(url) || (openBrowser(url), openedURLs.push(url));
 }
 function recursiveChunkGroup(chunkGroup, visited = new Set()) {
@@ -6327,7 +6325,7 @@ class SocketServer {
         });
     }
     onBuildDone() {
-        if (this.reportedBrowserLogs.clear(), this.socketsMap.size) for (let token of this.socketsMap.keys())this.sendStats({
+        if (this.reportedBrowserLogs.clear(), this.ensureInitialChunks(), this.socketsMap.size) for (let token of this.socketsMap.keys())this.sendStats({
             token
         });
     }
@@ -6375,9 +6373,11 @@ class SocketServer {
             socket.isAlive = !0;
         }), socket.on('message', async (data)=>{
             try {
-                let payload = JSON.parse('string' == typeof data ? data : data.toString()), { context } = this, config = context.normalizedConfig;
-                if (!config) return;
-                let { browserLogs, client } = config.dev;
+                let payload = JSON.parse('string' == typeof data ? data : data.toString()), { context } = this;
+                if (!context.normalizedConfig) return;
+                let environment = this.getEnvironmentByToken(token);
+                if (!environment) return;
+                let { browserLogs, client } = environment.config.dev;
                 if ('client-error' === payload.type && !context.buildState.hasErrors && browserLogs) {
                     let stackTrace = isObject(browserLogs) && browserLogs.stackTrace || DEFAULT_STACK_TRACE, outputFs = this.getOutputFileSystem(), stackFrames = payload.stack ? stack_trace_parser_esm_parse(payload.stack) : null, cachedTraceMap = new Map(), log = await formatBrowserErrorLog(payload.message, context, outputFs, stackTrace, stackFrames, cachedTraceMap);
                     if (this.reportedBrowserLogs.has(log) || (this.reportedBrowserLogs.add(log), src_logger.error(`${color.cyan('[browser]')} ${log}`)), 'object' == typeof client.overlay && client.overlay.runtime) {
@@ -6402,8 +6402,27 @@ class SocketServer {
             token
         });
     }
+    getEnvironmentByToken(token) {
+        return this.context.environmentList.find(({ webSocketToken })=>webSocketToken === token);
+    }
+    getInitialChunks(stats) {
+        let initialChunks = new Set();
+        if (!stats.entrypoints) return initialChunks;
+        for (let entrypoint of Object.values(stats.entrypoints)){
+            let { chunks } = entrypoint;
+            if (Array.isArray(chunks)) for (let chunkName of chunks)chunkName && initialChunks.add(String(chunkName));
+        }
+        return initialChunks;
+    }
+    ensureInitialChunks() {
+        for (let { webSocketToken } of this.context.environmentList){
+            if (this.initialChunksMap.has(webSocketToken)) continue;
+            let result = this.getStats(webSocketToken);
+            result && this.initialChunksMap.set(webSocketToken, this.getInitialChunks(result.stats));
+        }
+    }
     getStats(token) {
-        let { stats } = this.context.buildState, environment = this.context.environmentList.find(({ webSocketToken })=>webSocketToken === token);
+        let { stats } = this.context.buildState, environment = this.getEnvironmentByToken(token);
         if (!stats || !environment) return;
         let currentStats = stats;
         if (stats.children) {
@@ -6419,12 +6438,7 @@ class SocketServer {
     sendStats({ force = !1, token }) {
         let result = this.getStats(token);
         if (!result) return null;
-        let { stats, errors, warnings } = result, newInitialChunks = new Set();
-        if (stats.entrypoints) for (let entrypoint of Object.values(stats.entrypoints)){
-            let { chunks } = entrypoint;
-            if (Array.isArray(chunks)) for (let chunkName of chunks)chunkName && newInitialChunks.add(String(chunkName));
-        }
-        let initialChunks = this.initialChunksMap.get(token), shouldReload = stats.entrypoints && initialChunks && !isEqualSet(initialChunks, newInitialChunks);
+        let { stats, errors, warnings } = result, newInitialChunks = this.getInitialChunks(stats), initialChunks = this.initialChunksMap.get(token), shouldReload = stats.entrypoints && initialChunks && !isEqualSet(initialChunks, newInitialChunks);
         if (this.initialChunksMap.set(token, newInitialChunks), shouldReload) return void this.sockWrite({
             type: 'static-changed'
         }, token);
@@ -6590,7 +6604,7 @@ function historyApiFallback_historyApiFallbackMiddleware(options = {}) {
             src_logger.debug('Not rewriting', req.method, req.url, 'because the client did not send an HTTP accept header.'), next();
             return;
         }
-        if (0 === headers.accept.indexOf('application/json')) {
+        if (headers.accept.startsWith('application/json')) {
             src_logger.debug('Not rewriting', req.method, req.url, 'because the client prefers JSON.'), next();
             return;
         }
@@ -6608,11 +6622,11 @@ function historyApiFallback_historyApiFallbackMiddleware(options = {}) {
             let match = parsedUrl.pathname?.match(rewrite.from);
             if (!match) continue;
             let rule = rewrite.to;
-            '/' !== (rewriteTarget = 'string' == typeof rule ? rule : rule({
+            (rewriteTarget = 'string' == typeof rule ? rule : rule({
                 parsedUrl,
                 match,
                 request: req
-            })).charAt(0) && src_logger.debug('We recommend using an absolute path for the rewrite target.', 'Received a non-absolute rewrite target', rewriteTarget, 'for URL', req.url), src_logger.debug('Rewriting', req.method, req.url, 'to', rewriteTarget), req.url = rewriteTarget, next();
+            })).startsWith('/') || src_logger.debug('We recommend using an absolute path for the rewrite target.', 'Received a non-absolute rewrite target', rewriteTarget, 'for URL', req.url), src_logger.debug('Rewriting', req.method, req.url, 'to', rewriteTarget), req.url = rewriteTarget, next();
             return;
         }
         let { pathname } = parsedUrl;
@@ -6723,33 +6737,30 @@ async function createProxyMiddleware(proxyOptions) {
         }
     };
 }
-let applyDefaultMiddlewares = async ({ config, buildManager, context, devServerAPI, middlewares, postCallbacks })=>{
+let applyDefaultMiddlewares = async ({ config, buildManager, context, devServer, middlewares, postCallbacks })=>{
     let upgradeEvents = [], { server } = config;
     if (server.cors) {
         let { default: corsMiddleware } = await import("./cors.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/cors@2.8.6/node_modules/cors/lib/index.js", 23));
-        middlewares.push(corsMiddleware('boolean' == typeof server.cors ? {} : server.cors));
+        middlewares.use(corsMiddleware('boolean' == typeof server.cors ? {} : server.cors));
     }
     let { headers } = server;
-    if (headers && middlewares.push((_req, res, next)=>{
+    if (headers && middlewares.use((_req, res, next)=>{
         for (let [key, value] of Object.entries(headers))res.setHeader(key, value);
         next();
     }), server.proxy) {
         let { middlewares: proxyMiddlewares, upgrade } = await createProxyMiddleware(server.proxy);
-        for (let middleware of (upgradeEvents.push(upgrade), proxyMiddlewares))middlewares.push(middleware);
+        for (let middleware of (upgradeEvents.push(upgrade), proxyMiddlewares))middlewares.use(middleware);
     }
     let { compress } = server;
-    if (compress && middlewares.push(gzipMiddleware_gzipMiddleware('object' == typeof compress ? compress : void 0)), 'dev' === context.action && buildManager) {
+    if (compress && middlewares.use(gzipMiddleware_gzipMiddleware('object' == typeof compress ? compress : void 0)), 'dev' === context.action && buildManager) {
         let { compiler } = buildManager;
-        (compiler_isMultiCompiler(compiler) ? compiler.compilers.some((childCompiler)=>childCompiler.options.lazyCompilation) : compiler.options.lazyCompilation) && middlewares.push(core_rspack.lazyCompilationMiddleware(compiler));
+        (compiler_isMultiCompiler(compiler) ? compiler.compilers.some((childCompiler)=>childCompiler.options.lazyCompilation) : compiler.options.lazyCompilation) && middlewares.use(core_rspack.lazyCompilationMiddleware(compiler));
     }
-    server.base && '/' !== server.base && middlewares.push(getBaseUrlMiddleware({
+    server.base && '/' !== server.base && middlewares.use(getBaseUrlMiddleware({
         base: server.base
     }));
-    let { default: launchEditorMiddleware } = await import("./launch-editor-middleware.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/launch-editor-middleware@2.12.0/node_modules/launch-editor-middleware/index.js", 23));
-    if (middlewares.push([
-        '/__open-in-editor',
-        launchEditorMiddleware()
-    ]), middlewares.push((({ environments })=>async function viewingServedFilesMiddleware(req, res, next) {
+    let { default: launchEditorMiddleware } = await import("./launch-editor-middleware.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/launch-editor-middleware@2.13.0/node_modules/launch-editor-middleware/index.js", 23));
+    if (middlewares.use('/__open-in-editor', launchEditorMiddleware()), middlewares.use((({ environments })=>async function viewingServedFilesMiddleware(req, res, next) {
             if ('/rsbuild-dev-server' !== req.url.replace(postfixRE, '')) return void next();
             res.writeHead(200, {
                 'Content-Type': 'text/html; charset=utf-8'
@@ -6808,10 +6819,10 @@ let applyDefaultMiddlewares = async ({ config, buildManager, context, devServerA
                 src_logger.error(err), res.writeHead(500), res.end('Failed to list the files');
             }
         })({
-        environments: devServerAPI.environments
-    })), buildManager && (middlewares.push(buildManager.assetsMiddleware), upgradeEvents.push(buildManager.socketServer.upgrade), middlewares.push(function hotUpdateJsonFallbackMiddleware(req, res, next) {
+        environments: devServer.environments
+    })), buildManager && (middlewares.use(buildManager.assetsMiddleware), upgradeEvents.push(buildManager.socketServer.upgrade), middlewares.use(function hotUpdateJsonFallbackMiddleware(req, res, next) {
         req.url?.endsWith('.hot-update.json') && 'OPTIONS' !== req.method ? notFoundMiddleware(req, res, next) : next();
-    })), buildManager && middlewares.push((({ distPath, buildManager })=>async function htmlCompletionMiddleware(req, res, next) {
+    })), buildManager && middlewares.use((({ distPath, buildManager })=>async function htmlCompletionMiddleware(req, res, next) {
             if (!maybeHTMLRequest(req)) return void next();
             let pathname = req.url.replace(postfixRE, ''), rewrite = (newUrl)=>{
                 req.url = newUrl, buildManager.assetsMiddleware(req, res, (...args)=>{
@@ -6838,14 +6849,14 @@ let applyDefaultMiddlewares = async ({ config, buildManager, context, devServerA
                 etag: !0,
                 dev: !0
             });
-            middlewares.push(function publicDirMiddleware(req, res, next) {
+            middlewares.use(function publicDirMiddleware(req, res, next) {
                 sirvMiddleware(req, res, next);
             });
         }
     }
-    for (let callback of postCallbacks)callback();
-    return server.historyApiFallback && (middlewares.push(historyApiFallback_historyApiFallbackMiddleware(!0 === server.historyApiFallback ? {} : server.historyApiFallback)), buildManager?.assetsMiddleware && middlewares.push(buildManager.assetsMiddleware)), buildManager && middlewares.push((({ htmlFallback, distPath, buildManager })=>async function htmlFallbackMiddleware(req, res, next) {
-            if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url || 'index' !== htmlFallback) return void next();
+    for (let callback of postCallbacks)await callback();
+    return server.historyApiFallback && (middlewares.use(historyApiFallback_historyApiFallbackMiddleware(!0 === server.historyApiFallback ? {} : server.historyApiFallback)), buildManager?.assetsMiddleware && middlewares.use(buildManager.assetsMiddleware)), buildManager && server.htmlFallback && middlewares.use((({ distPath, buildManager })=>async function htmlFallbackMiddleware(req, res, next) {
+            if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url) return void next();
             let filePath = external_node_path_.default.join(distPath, 'index.html');
             if (await middlewares_isFileExists(filePath, buildManager.outputFileSystem)) {
                 let newUrl = '/index.html';
@@ -6857,22 +6868,23 @@ let applyDefaultMiddlewares = async ({ config, buildManager, context, devServerA
             next();
         })({
         buildManager,
-        distPath: context.distPath,
-        htmlFallback: server.htmlFallback
-    })), middlewares.push(faviconFallbackMiddleware), {
+        distPath: context.distPath
+    })), middlewares.use(faviconFallbackMiddleware), {
         onUpgrade: (...args)=>{
             for (let cb of upgradeEvents)cb(...args);
         }
     };
 }, getDevMiddlewares = async (options)=>{
-    let middlewares = [], { buildManager } = options;
-    isVerbose() && middlewares.push(getRequestLoggerMiddleware());
-    let { before, after } = ((config, devServerAPI)=>{
-        let setupMiddlewares = config.dev.setupMiddlewares || [], serverOptions = pick(devServerAPI, [
+    let { buildManager, devServer } = options, { middlewares } = devServer;
+    isVerbose() && middlewares.use(getRequestLoggerMiddleware());
+    let { before, after } = ((config, devServer)=>{
+        let setupMiddlewares = config.dev.setupMiddlewares ? helpers_castArray(config.dev.setupMiddlewares) : [];
+        setupMiddlewares.length && src_logger.warn('[rsbuild] `dev.setupMiddlewares` is deprecated, use `server.setup` instead');
+        let serverOptions = pick(devServer, [
             'sockWrite',
             'environments'
         ]), before = [], after = [];
-        for (let handler of helpers_castArray(setupMiddlewares))handler({
+        for (let handler of setupMiddlewares)handler({
             unshift: (...handlers)=>before.unshift(...handlers),
             push: (...handlers)=>after.push(...handlers)
         }, serverOptions);
@@ -6880,18 +6892,18 @@ let applyDefaultMiddlewares = async ({ config, buildManager, context, devServerA
             before,
             after
         };
-    })(options.config, options.devServerAPI);
-    middlewares.push(...before);
+    })(options.config, options.devServer);
+    for (let middleware of before)middlewares.use(middleware);
     let { onUpgrade } = await applyDefaultMiddlewares({
         ...options,
         middlewares
     });
-    return middlewares.push(...after), {
+    for (let middleware of after)middlewares.use(middleware);
+    return {
         close: async ()=>{
             await buildManager?.close();
         },
-        onUpgrade,
-        middlewares
+        onUpgrade
     };
 }, asModule = async (something, context, unlinked)=>{
     let { Module, SyntheticModule } = await import("node:vm");
@@ -7162,6 +7174,14 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>{
     let { createServer } = await import("node:http");
     return createServer(middlewares);
 };
+async function applyServerSetup(setup, context) {
+    let postCallbacks = [];
+    for (let handler of helpers_castArray(setup || [])){
+        let postCallback = await handler(context);
+        'function' == typeof postCallback && postCallbacks.push(postCallback);
+    }
+    return postCallbacks;
+}
 async function setupWatchFiles(options) {
     let { config, root, buildManager } = options, { hmr, liveReload } = config.dev;
     if (!hmr && !liveReload || !buildManager) return;
@@ -7227,15 +7247,13 @@ async function startWatchFiles({ paths, options, type = 'reload-page' }, buildMa
     }), watcher;
 }
 async function devServer_createDevServer(options, createCompiler, config, { getPortSilently, runCompile = !0 } = {}) {
-    let lastStats, fileWatcher, devMiddlewares;
+    let lastStats, fileWatcher, devMiddlewares, buildManager;
     src_logger.debug('create dev server');
-    let { port, host, https, portTip } = await getServerConfig({
-        config
-    }), { middlewareMode } = config.server, { context } = options, routes = getRoutes(context), root = context.rootPath;
+    let { port, portTip } = await resolvePort(config), { middlewareMode, host } = config.server, isHttps = !!config.server.https, { context } = options, routes = getRoutes(context);
     context.devServer = {
         hostname: host,
         port,
-        https
+        https: isHttps
     };
     let waitLastCompileDoneResolve = null, waitLastCompileDone = new Promise((resolve)=>{
         waitLastCompileDoneResolve = resolve;
@@ -7263,7 +7281,7 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
             resolvedPort: port
         });
         return await buildManager.init(), buildManager;
-    }, protocol = https ? 'https' : 'http', urls = await getAddressUrls({
+    }, protocol = isHttps ? 'https' : 'http', urls = await getAddressUrls({
         protocol,
         port,
         host
@@ -7276,10 +7294,10 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
             trailingLineBreak: !cliShortcutsEnabled,
             originalConfig: context.originalConfig
         }), openPage = async ()=>open_open({
-            https,
             port,
             routes,
             config,
+            protocol,
             clearCache: !0
         }), cleanupGracefulShutdown = middlewareMode ? null : setupGracefulShutdown(), closingPromise = null, closeServer = async ()=>(closingPromise || (closingPromise = (async ()=>{
             removeCleanup(closeServer), cleanupGracefulShutdown?.(), await context.hooks.onCloseDevServer.callBatch(), await Promise.all([
@@ -7335,7 +7353,7 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
     let { default: connect } = await import("./connect.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/connect@3.7.0_supports-color@10.2.2/node_modules/connect/index.js", 23)), middlewares = connect(), httpServer = middlewareMode ? null : await createHttpServer({
         serverConfig: config.server,
         middlewares
-    }), devServerAPI = {
+    }), devServer = {
         port,
         middlewares,
         environments: environmentAPI,
@@ -7353,12 +7371,10 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
                     port
                 }, async (err)=>{
                     if (err) throw err;
-                    middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), devMiddlewares && httpServer.on('upgrade', devMiddlewares.onUpgrade), src_logger.debug('listen dev server done'), await devServerAPI.afterListen(), onBeforeRestartServer(devServerAPI.close), resolve({
+                    middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), devMiddlewares && httpServer.on('upgrade', devMiddlewares.onUpgrade), src_logger.debug('listen dev server done'), await devServer.afterListen(), onBeforeRestartServer(devServer.close), resolve({
                         port,
                         urls: urls.map((item)=>item.url),
-                        server: {
-                            close: devServerAPI.close
-                        }
+                        server: devServer
                     });
                 });
             });
@@ -7376,134 +7392,119 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
         close: closeServer,
         printUrls,
         open: openPage
-    }, postCallbacks = (await context.hooks.onBeforeStartDevServer.callBatch({
-        server: devServerAPI,
+    }, setupPostCallbacks = await applyServerSetup(config.server.setup, {
+        action: 'dev',
+        server: devServer,
         environments: context.environments
-    })).filter((item)=>'function' == typeof item);
-    runCompile ? context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : await beforeCreateCompiler();
-    let buildManager = runCompile ? await startCompile() : void 0;
-    for (let item of (fileWatcher = await setupWatchFiles({
+    }), postCallbacks = [
+        ...(await context.hooks.onBeforeStartDevServer.callBatch({
+            server: devServer,
+            environments: context.environments
+        })).filter((item)=>'function' == typeof item),
+        ...setupPostCallbacks
+    ];
+    return runCompile ? context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : await beforeCreateCompiler(), buildManager = runCompile ? await startCompile() : void 0, fileWatcher = await setupWatchFiles({
         config,
         buildManager,
-        root
-    }), (devMiddlewares = await getDevMiddlewares({
+        root: context.rootPath
+    }), devMiddlewares = await getDevMiddlewares({
         buildManager,
         config,
-        devServerAPI,
+        devServer,
         context,
         postCallbacks
-    })).middlewares))Array.isArray(item) ? middlewares.use(...item) : middlewares.use(item);
-    return buildManager?.watch(), src_logger.debug('create dev server done'), devServerAPI;
+    }), buildManager?.watch(), src_logger.debug('create dev server done'), devServer;
 }
-class RsbuildProdServer {
-    app;
-    options;
-    middlewares;
-    constructor(options, middlewares){
-        this.options = options, this.middlewares = middlewares;
-    }
-    async onInit(app) {
-        this.app = app, await this.applyDefaultMiddlewares();
-    }
-    async applyDefaultMiddlewares() {
-        let { headers, proxy, historyApiFallback, compress, base, cors } = this.options.serverConfig;
-        if (isVerbose() && this.middlewares.use(getRequestLoggerMiddleware()), cors) {
-            let { default: corsMiddleware } = await import("./cors.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/cors@2.8.6/node_modules/cors/lib/index.js", 23));
-            this.middlewares.use(corsMiddleware('boolean' == typeof cors ? {} : cors));
-        }
-        if (headers && this.middlewares.use((_req, res, next)=>{
-            for (let [key, value] of Object.entries(headers))res.setHeader(key, value);
-            next();
-        }), proxy) {
-            let { middlewares, upgrade } = await createProxyMiddleware(proxy);
-            for (let middleware of middlewares)this.middlewares.use(middleware);
-            this.app.on('upgrade', upgrade);
-        }
-        if (compress) {
-            let { constants } = await import("node:zlib");
-            this.middlewares.use(gzipMiddleware_gzipMiddleware({
-                level: constants.Z_DEFAULT_COMPRESSION,
-                ...'object' == typeof compress ? compress : void 0
-            }));
-        }
-        base && '/' !== base && this.middlewares.use(getBaseUrlMiddleware({
-            base
-        })), await this.applyStaticAssetMiddleware(), historyApiFallback && (this.middlewares.use(historyApiFallback_historyApiFallbackMiddleware(!0 === historyApiFallback ? {} : historyApiFallback)), await this.applyStaticAssetMiddleware()), this.middlewares.use(faviconFallbackMiddleware), this.middlewares.use(optionsFallbackMiddleware), this.middlewares.use(notFoundMiddleware);
-    }
-    async applyStaticAssetMiddleware() {
-        let { output: { path, assetPrefixes }, serverConfig: { htmlFallback } } = this.options, { default: sirv } = await import("./sirv.js").then((mod)=>({
+async function startPreviewServer(context, config, { getPortSilently } = {}) {
+    let { default: connect } = await import("./connect.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/connect@3.7.0_supports-color@10.2.2/node_modules/connect/index.js", 23)), middlewares = connect(), { port, portTip } = await resolvePort(config), serverConfig = config.server, { host, headers, proxy, historyApiFallback, compress, base, cors } = serverConfig, protocol = serverConfig.https ? 'https' : 'http', routes = getRoutes(context), urls = await getAddressUrls({
+        protocol,
+        port,
+        host
+    }), cliShortcutsEnabled = isCliShortcutsEnabled(config), httpServer = await createHttpServer({
+        serverConfig,
+        middlewares
+    }), cleanupGracefulShutdown = setupGracefulShutdown(), serverTerminator = getServerTerminator(httpServer), closingPromise = null, closeServer = async ()=>(closingPromise || (closingPromise = (async ()=>{
+            removeCleanup(closeServer), cleanupGracefulShutdown(), await serverTerminator();
+        })()), closingPromise), printUrls = ()=>printServerURLs({
+            urls,
+            port,
+            routes,
+            protocol,
+            printUrls: serverConfig.printUrls,
+            trailingLineBreak: !cliShortcutsEnabled,
+            originalConfig: context.originalConfig
+        }), openPage = async ()=>open_open({
+            port,
+            routes,
+            config,
+            protocol,
+            clearCache: !0
+        }), previewServer = {
+        httpServer,
+        port,
+        middlewares,
+        close: closeServer,
+        printUrls,
+        open: openPage
+    }, postSetupCallbacks = await applyServerSetup(serverConfig.setup, {
+        action: 'preview',
+        server: previewServer,
+        environments: context.environments
+    });
+    await context.hooks.onBeforeStartPreviewServer.callBatch({
+        server: previewServer,
+        environments: context.environments
+    });
+    let applyStaticAssetMiddleware = async ()=>{
+        let { default: sirv } = await import("./sirv.js").then((mod)=>({
                 default: mod.build
-            })), assetsMiddleware = sirv(path, {
+            })), assetsMiddleware = sirv(context.distPath, {
             etag: !0,
             dev: !0,
             ignores: [
                 'favicon.ico'
             ],
-            single: 'index' === htmlFallback
-        });
-        this.middlewares.use(function staticAssetMiddleware(req, res, next) {
-            let url = req.url, assetPrefix = url && assetPrefixes.find((prefix)=>url.startsWith(prefix));
+            single: 'index' === serverConfig.htmlFallback
+        }), assetPrefixes = context.environmentList.map((e)=>getPathnameFromUrl(e.config.output.assetPrefix));
+        middlewares.use(function staticAssetMiddleware(req, res, next) {
+            let { url } = req, assetPrefix = url && assetPrefixes.find((prefix)=>url.startsWith(prefix));
             assetPrefix && url?.startsWith(assetPrefix) ? (req.url = url.slice(assetPrefix.length), assetsMiddleware(req, res, (...args)=>{
                 req.url = url, next(...args);
             })) : assetsMiddleware(req, res, next);
         });
+    };
+    if (isVerbose() && middlewares.use(getRequestLoggerMiddleware()), cors) {
+        let { default: corsMiddleware } = await import("./cors.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/cors@2.8.6/node_modules/cors/lib/index.js", 23));
+        middlewares.use(corsMiddleware('boolean' == typeof cors ? {} : cors));
     }
-    async close() {}
-}
-async function startProdServer(context, config, { getPortSilently } = {}) {
-    let { port, host, https, portTip } = await getServerConfig({
-        config
-    }), { default: connect } = await import("./connect.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/connect@3.7.0_supports-color@10.2.2/node_modules/connect/index.js", 23)), middlewares = connect(), serverConfig = config.server, server = new RsbuildProdServer({
-        pwd: context.rootPath,
-        output: {
-            path: context.distPath,
-            assetPrefixes: context.environmentList.map((e)=>getPathnameFromUrl(e.config.output.assetPrefix))
-        },
-        serverConfig
-    }, middlewares);
-    await context.hooks.onBeforeStartProdServer.callBatch();
-    let httpServer = await createHttpServer({
-        serverConfig,
-        middlewares: server.middlewares
-    }), serverTerminator = getServerTerminator(httpServer);
-    return await server.onInit(httpServer), new Promise((resolve)=>{
+    if (headers && middlewares.use((_req, res, next)=>{
+        for (let [key, value] of Object.entries(headers))res.setHeader(key, value);
+        next();
+    }), proxy) {
+        let { middlewares: proxyMiddlewares, upgrade } = await createProxyMiddleware(proxy);
+        for (let middleware of proxyMiddlewares)middlewares.use(middleware);
+        httpServer.on('upgrade', upgrade);
+    }
+    if (compress) {
+        let { constants } = await import("node:zlib");
+        middlewares.use(gzipMiddleware_gzipMiddleware({
+            level: constants.Z_DEFAULT_COMPRESSION,
+            ...'object' == typeof compress ? compress : void 0
+        }));
+    }
+    for (let callback of (base && '/' !== base && middlewares.use(getBaseUrlMiddleware({
+        base
+    })), await applyStaticAssetMiddleware(), historyApiFallback && (middlewares.use(historyApiFallback_historyApiFallbackMiddleware(!0 === historyApiFallback ? {} : historyApiFallback)), await applyStaticAssetMiddleware()), postSetupCallbacks))await callback();
+    return middlewares.use(faviconFallbackMiddleware), middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), new Promise((resolve)=>{
         httpServer.listen({
             host,
             port
         }, async ()=>{
-            let routes = getRoutes(context);
-            await context.hooks.onAfterStartProdServer.callBatch({
+            if (await context.hooks.onAfterStartPreviewServer.callBatch({
                 port,
                 routes,
                 environments: context.environments
-            });
-            let protocol = https ? 'https' : 'http', urls = await getAddressUrls({
-                protocol,
-                port,
-                host
-            }), cliShortcutsEnabled = isCliShortcutsEnabled(config), cleanupGracefulShutdown = setupGracefulShutdown(), closingPromise = null, closeServer = async ()=>(closingPromise || (closingPromise = (async ()=>{
-                    removeCleanup(closeServer), cleanupGracefulShutdown(), await Promise.all([
-                        server.close(),
-                        serverTerminator()
-                    ]);
-                })()), closingPromise);
-            registerCleanup(closeServer);
-            let printUrls = ()=>printServerURLs({
-                    urls,
-                    port,
-                    routes,
-                    protocol,
-                    printUrls: serverConfig.printUrls,
-                    trailingLineBreak: !cliShortcutsEnabled,
-                    originalConfig: context.originalConfig
-                }), openPage = async ()=>open_open({
-                    https,
-                    port,
-                    routes,
-                    config,
-                    clearCache: !0
-                });
-            if (printUrls(), cliShortcutsEnabled) {
+            }), registerCleanup(closeServer), printUrls(), cliShortcutsEnabled) {
                 let shortcutsOptions = 'boolean' == typeof config.dev.cliShortcuts ? {} : config.dev.cliShortcuts;
                 await setupCliShortcuts({
                     openPage,
@@ -7516,9 +7517,7 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
             !getPortSilently && portTip && src_logger.info(portTip), resolve({
                 port,
                 urls: urls.map((item)=>item.url),
-                server: {
-                    close: closeServer
-                }
+                server: previewServer
             });
         });
     });
@@ -8534,14 +8533,17 @@ try {
             setup (api) {
                 let onStartServer = ({ port, routes })=>{
                     let config = api.getNormalizedConfig();
-                    config.server.open && open_open({
-                        https: api.context.devServer?.https,
-                        port,
-                        routes,
-                        config
-                    });
+                    if (config.server.open) {
+                        let protocol = config.server.https ? 'https' : 'http';
+                        open_open({
+                            port,
+                            routes,
+                            config,
+                            protocol
+                        });
+                    }
                 };
-                api.onAfterStartDevServer(onStartServer), api.onAfterStartProdServer(onStartServer), api.onBeforeBuild(async ({ isFirstCompile, environments })=>{
+                api.onAfterStartDevServer(onStartServer), api.onAfterStartPreviewServer(onStartServer), api.onBeforeBuild(async ({ isFirstCompile, environments })=>{
                     if (isFirstCompile) for (let { name: publicDir, copyOnBuild, ignore } of api.getNormalizedConfig().server.publicDir){
                         let shouldCopy;
                         if (!1 === copyOnBuild || !external_node_fs_.default.existsSync(publicDir)) continue;
@@ -8588,7 +8590,7 @@ try {
                 api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, isDev })=>{
                     let { output: { manifest }, dev: { writeToDisk } } = environment.config;
                     if (!1 === manifest) return;
-                    let manifestOptions = normalizeManifestObjectConfig(manifest), { RspackManifestPlugin } = await import("./manifest-plugin.js").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-beta.2_@module-federation+runtime-tools@2.0.0_@swc+helpers@0.5.18_/node_modules/rspack-manifest-plugin/dist/index.js")), { htmlPaths } = environment, filter = manifestOptions.filter ?? ((file)=>!file.name.endsWith('.LICENSE.txt'));
+                    let manifestOptions = normalizeManifestObjectConfig(manifest), { RspackManifestPlugin } = await import("./manifest-plugin.js").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-beta.3_@module-federation+runtime-tools@2.0.1_@swc+helpers@0.5.19_/node_modules/rspack-manifest-plugin/dist/index.js")), { htmlPaths } = environment, filter = manifestOptions.filter ?? ((file)=>!file.name.endsWith('.LICENSE.txt'));
                     manifestFilenames.set(environment.name, manifestOptions.filename);
                     let pluginOptions = {
                         fileName: manifestOptions.filename,
@@ -8823,7 +8825,7 @@ async function createRsbuild(options = {}) {
                 if (!(0, external_node_fs_.existsSync)(distPath)) throw Error(`${color.dim('[rsbuild:preview]')} The output directory ${color.yellow(distPath)} does not exist, please build the project before previewing.`);
                 if (isEmptyDir(distPath)) throw Error(`${color.dim('[rsbuild:preview]')} The output directory ${color.yellow(distPath)} is empty, please build the project before previewing.`);
             }
-            return startProdServer(context, config, options);
+            return startPreviewServer(context, config, options);
         },
         startDevServer: async (options)=>{
             context.action = 'dev', process.env.NODE_ENV || setNodeEnv('development');
@@ -8885,13 +8887,13 @@ async function createRsbuild(options = {}) {
             'onAfterDevCompile',
             'onAfterEnvironmentCompile',
             'onAfterStartDevServer',
-            'onAfterStartProdServer',
+            'onAfterStartPreviewServer',
             'onBeforeBuild',
             'onBeforeCreateCompiler',
             'onBeforeDevCompile',
             'onBeforeEnvironmentCompile',
             'onBeforeStartDevServer',
-            'onBeforeStartProdServer',
+            'onBeforeStartPreviewServer',
             'onCloseBuild',
             'onCloseDevServer',
             'onDevCompileDone',
@@ -9093,7 +9095,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands() {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.0.0-beta.4"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.0.0-beta.6"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -9162,7 +9164,7 @@ function initNodeEnv() {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.0-beta.4\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.0-beta.6\n`);
 }
 function setupLogLevel() {
     let logLevelIndex = process.argv.findIndex((item)=>'--log-level' === item || '--logLevel' === item);
@@ -9183,5 +9185,5 @@ function runCLI() {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.0.0-beta.4";
+let src_version = "2.0.0-beta.6";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, external_node_util_promisify, loadConfig_loadConfig as loadConfig, loadEnv, mergeRsbuildConfig, runCLI, src_logger as logger, src_version as version };