@rsbuild/core 1.2.3 → 1.2.5

package/dist/index.cjs

@@ -384,7 +384,6 @@ var __webpack_exports__ = {};
     });
     var provider_helpers_namespaceObject = {};
     __webpack_require__.r(provider_helpers_namespaceObject), __webpack_require__.d(provider_helpers_namespaceObject, {
-        chainToConfig: ()=>chainToConfig,
         createDevServer: ()=>devServer_createDevServer,
         formatStats: ()=>formatStats,
         getChainUtils: ()=>getChainUtils,
@@ -919,36 +918,42 @@ var __webpack_exports__ = {};
     async function init({ cliOptions, isRestart, isBuildWatch = !1 }) {
         cliOptions && (commonOpts = cliOptions);
         try {
-            var _config_server, _config_dev, _config_dev1;
+            var _config_server, _config_dev;
             let cwd = process.cwd(), root = commonOpts.root ? getAbsolutePath(cwd, commonOpts.root) : cwd, envs = loadEnv({
                 cwd: getEnvDir(root, commonOpts.envDir),
                 mode: commonOpts.envMode
             }), { content: config, filePath: configFilePath } = await config_loadConfig({
                 cwd: root,
                 path: commonOpts.config,
-                envMode: commonOpts.envMode
-            }), command = process.argv[2];
-            if ('dev' === command || isBuildWatch) {
-                let files = [
-                    ...envs.filePaths
-                ];
-                if (configFilePath && files.push(configFilePath), null === (_config_dev1 = config.dev) || void 0 === _config_dev1 ? void 0 : _config_dev1.watchFiles) for (let watchFilesConfig of castArray(config.dev.watchFiles)){
-                    if ('reload-server' !== watchFilesConfig.type) continue;
-                    let paths = castArray(watchFilesConfig.paths);
-                    watchFilesConfig.options ? watchFilesForRestart(paths, root, isBuildWatch, watchFilesConfig.options) : files.push(...paths);
-                }
-                watchFilesForRestart(files, root, isBuildWatch);
-            }
+                envMode: commonOpts.envMode,
+                loader: commonOpts.configLoader
+            });
             config.source ||= {}, config.source.define = {
                 ...envs.publicVars,
                 ...config.source.define
-            }, commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), !commonOpts.open || (null === (_config_server = config.server) || void 0 === _config_server ? void 0 : _config_server.open) || (config.server ||= {}, config.server.open = commonOpts.open), commonOpts.host && (config.server ||= {}, config.server.host = commonOpts.host), commonOpts.port && (config.server ||= {}, config.server.port = commonOpts.port), (null === (_config_dev = config.dev) || void 0 === _config_dev ? void 0 : _config_dev.cliShortcuts) === void 0 && (config.dev ||= {}, config.dev.cliShortcuts = !0);
+            }, commonOpts.base && (config.server ||= {}, config.server.base = commonOpts.base), commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), !commonOpts.open || (null === (_config_server = config.server) || void 0 === _config_server ? void 0 : _config_server.open) || (config.server ||= {}, config.server.open = commonOpts.open), commonOpts.host && (config.server ||= {}, config.server.host = commonOpts.host), commonOpts.port && (config.server ||= {}, config.server.port = commonOpts.port), (null === (_config_dev = config.dev) || void 0 === _config_dev ? void 0 : _config_dev.cliShortcuts) === void 0 && (config.dev ||= {}, config.dev.cliShortcuts = !0);
             let rsbuild = await createRsbuild({
                 cwd: root,
                 rsbuildConfig: config,
                 environment: commonOpts.environment
             });
-            return rsbuild.onCloseBuild(envs.cleanup), rsbuild.onCloseDevServer(envs.cleanup), rsbuild;
+            return rsbuild.onBeforeCreateCompiler(()=>{
+                let command = process.argv[2];
+                if ('dev' === command || isBuildWatch) {
+                    var _config_dev;
+                    let files = [
+                        ...envs.filePaths
+                    ];
+                    configFilePath && files.push(configFilePath);
+                    let config = rsbuild.getNormalizedConfig();
+                    if (null === (_config_dev = config.dev) || void 0 === _config_dev ? void 0 : _config_dev.watchFiles) for (let watchFilesConfig of castArray(config.dev.watchFiles)){
+                        if ('reload-server' !== watchFilesConfig.type) continue;
+                        let paths = castArray(watchFilesConfig.paths);
+                        watchFilesConfig.options ? watchFilesForRestart(paths, root, isBuildWatch, watchFilesConfig.options) : files.push(...paths);
+                    }
+                    watchFilesForRestart(files, root, isBuildWatch);
+                }
+            }), rsbuild.onCloseBuild(envs.cleanup), rsbuild.onCloseDevServer(envs.cleanup), rsbuild;
         } catch (err) {
             if (isRestart) rslog_index_js_namespaceObject.logger.error(err);
             else throw err;
@@ -1104,7 +1109,6 @@ var __webpack_exports__ = {};
             }
         }), getDefaultPerformanceConfig = ()=>({
             profile: !1,
-            buildCache: !0,
             printFileSize: !0,
             removeConsole: !1,
             removeMomentLocale: !1,
@@ -1237,7 +1241,7 @@ var __webpack_exports__ = {};
         });
         watcher.on('add', callback), watcher.on('change', callback), watcher.on('unlink', callback);
     }
-    async function config_loadConfig({ cwd = process.cwd(), path, envMode, meta } = {}) {
+    async function config_loadConfig({ cwd = process.cwd(), path, envMode, meta, loader = 'jiti' } = {}) {
         let configExport;
         let configFilePath = resolveConfigPath(cwd, path);
         if (!configFilePath) return {
@@ -1247,10 +1251,11 @@ var __webpack_exports__ = {};
         let applyMetaInfo = (config)=>(config._privateMeta = {
                 configFilePath
             }, config);
-        if (/\.(?:js|mjs|cjs)$/.test(configFilePath)) try {
-            let exportModule = await import(`${configFilePath}?t=${Date.now()}`);
+        if ('native' === loader || /\.(?:js|mjs|cjs)$/.test(configFilePath)) try {
+            let configFileURL = (0, external_node_url_namespaceObject.pathToFileURL)(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
             configExport = exportModule.default ? exportModule.default : exportModule;
         } catch (err) {
+            if ('native' === loader) throw rslog_index_js_namespaceObject.logger.error(`Failed to load file with native loader: ${index_js_default().dim(configFilePath)}`), err;
             rslog_index_js_namespaceObject.logger.debug(`Failed to load file with dynamic import: ${index_js_default().dim(configFilePath)}`);
         }
         try {
@@ -1703,7 +1708,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.3",
+            version: "1.2.5",
             rootPath,
             distPath: '',
             cachePath,
@@ -1846,26 +1851,6 @@ var __webpack_exports__ = {};
         if (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.bundlerChain) for (let item of castArray(utils.environment.config.tools.bundlerChain))await item(modifiedBundlerChain, utils);
         return rslog_index_js_namespaceObject.logger.debug('modify bundler chain done'), modifiedBundlerChain;
     }
-    function chainToConfig(chain) {
-        let config = chain.toConfig(), { entry } = config;
-        if (!isPlainObject(entry)) return config;
-        let formattedEntry = {};
-        for (let [entryName, entryValue] of Object.entries(entry)){
-            let entryImport = [], entryDescription = null;
-            for (let item of castArray(entryValue)){
-                if ('string' == typeof item) {
-                    entryImport.push(item);
-                    continue;
-                }
-                item.import && entryImport.push(...castArray(item.import)), entryDescription ? Object.assign(entryDescription, item) : entryDescription = item;
-            }
-            formattedEntry[entryName] = entryDescription ? {
-                ...entryDescription,
-                import: entryImport
-            } : entryImport;
-        }
-        return config.entry = formattedEntry, config;
-    }
     let configChain_CHAIN_ID = {
         RULE: {
             MJS: 'mjs',
@@ -1993,7 +1978,7 @@ var __webpack_exports__ = {};
                     }
                 });
             }
-        }), getJsSourceMap = (config)=>{
+        }), getDevtool = (config)=>{
         let { sourceMap } = config.output, isProd = 'production' === config.mode;
         return !1 !== sourceMap && (!0 === sourceMap ? isProd ? 'source-map' : 'cheap-module-source-map' : void 0 === sourceMap.js ? !isProd && 'cheap-module-source-map' : sourceMap.js);
     }, pluginBasic = ()=>({
@@ -2001,7 +1986,16 @@ var __webpack_exports__ = {};
             setup (api) {
                 api.modifyBundlerChain((chain, { env, isDev, target, bundler, environment, CHAIN_ID })=>{
                     let { config } = environment;
-                    chain.name(environment.name), chain.devtool(getJsSourceMap(config)), chain.context(api.context.rootPath), chain.mode(environment.config.mode), chain.merge({
+                    chain.name(environment.name);
+                    let devtool = getDevtool(config);
+                    chain.devtool(devtool);
+                    let { sourceMap } = config.output;
+                    !devtool && 'object' == typeof sourceMap && sourceMap.css && chain.plugin('source-map-css').use(bundler.SourceMapDevToolPlugin, [
+                        {
+                            test: /\.css$/,
+                            filename: '[file].map[query]'
+                        }
+                    ]), chain.context(api.context.rootPath), chain.mode(environment.config.mode), chain.merge({
                         infrastructureLogging: {
                             level: 'error'
                         }
@@ -2023,10 +2017,16 @@ var __webpack_exports__ = {};
         return process.env.BUNDLE_ANALYZE || (null === (_config_performance = config.performance) || void 0 === _config_performance ? void 0 : _config_performance.bundleAnalyze);
     }, external_node_crypto_namespaceObject = require("node:crypto");
     var external_node_crypto_default = __webpack_require__.n(external_node_crypto_namespaceObject);
-    async function validateCache(cacheDirectory, buildDependencies) {
+    async function validateWebpackCache(cacheDirectory, buildDependencies) {
         let configFile = (0, external_node_path_namespaceObject.join)(cacheDirectory, 'buildDependencies.json');
         if (await isFileExists(configFile)) {
-            if (JSON.stringify(JSON.parse(await external_node_fs_default().promises.readFile(configFile, 'utf-8'))) === JSON.stringify(buildDependencies)) return;
+            let rawConfigFile = await external_node_fs_default().promises.readFile(configFile, 'utf-8'), prevBuildDependencies = null;
+            try {
+                prevBuildDependencies = JSON.parse(rawConfigFile);
+            } catch (e) {
+                rslog_index_js_namespaceObject.logger.debug('Failed to parse the previous buildDependencies.json', e);
+            }
+            if (JSON.stringify(prevBuildDependencies) === JSON.stringify(buildDependencies)) return;
             await external_node_fs_default().promises.rm(cacheDirectory, {
                 force: !0,
                 recursive: !0
@@ -2063,24 +2063,33 @@ var __webpack_exports__ = {};
     let pluginCache = ()=>({
             name: 'rsbuild:cache',
             setup (api) {
-                'rspack' !== api.context.bundlerType && api.modifyBundlerChain(async (chain, { environment, env })=>{
+                let cacheEnabled = !1;
+                api.modifyBundlerChain(async (chain, { environment, env })=>{
                     var digest;
-                    let { config } = environment, { buildCache } = config.performance;
-                    if (!1 === buildCache) {
-                        chain.cache(!1);
-                        return;
-                    }
+                    let { config } = environment, { bundlerType } = api.context, buildCache = config.performance.buildCache ?? 'webpack' === bundlerType;
+                    if (!1 === buildCache) return;
+                    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);
-                    await validateCache(cacheDirectory, buildDependencies);
-                    let useDigest = Array.isArray(cacheConfig.cacheDigest) && cacheConfig.cacheDigest.length;
-                    chain.cache({
-                        name: useDigest ? `${environment.name}-${env}-${digest = cacheConfig.cacheDigest, external_node_crypto_default().createHash('md5').update(JSON.stringify(digest)).digest('hex').slice(0, 8)}` : `${environment.name}-${env}`,
+                    '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({
+                        ...chain.get('experiments'),
+                        cache: {
+                            type: 'persistent',
+                            version: cacheVersion,
+                            directory: cacheDirectory,
+                            buildDependencies: Object.values(buildDependencies).flat()
+                        }
+                    })) : chain.cache({
+                        name: cacheVersion,
                         type: 'filesystem',
                         cacheDirectory,
                         buildDependencies
                     });
+                }), api.onAfterCreateCompiler(()=>{
+                    cacheEnabled && 'rspack' === api.context.bundlerType && rslog_index_js_namespaceObject.logger.info(`Rspack persistent cache enabled ${index_js_default().dim('(experimental)')}`);
                 });
             }
         }), addTrailingSep = (dir)=>dir.endsWith(external_node_path_namespaceObject.sep) ? dir : dir + external_node_path_namespaceObject.sep, isStrictSubdir = (parent, child)=>{
@@ -2105,9 +2114,9 @@ var __webpack_exports__ = {};
                     if (!0 === enable || 'auto' === enable && isStrictSubdir(rootPath, targetPath)) return {
                         path: targetPath
                     };
-                }, getPathInfo = (environment)=>{
+                }, getPathInfo = (environment, isDev)=>{
                     let { rootPath } = api.context, { config, distPath } = environment, { enable, keep } = normalizeCleanDistPath(config.output.cleanDistPath);
-                    return 'auto' === enable ? isStrictSubdir(rootPath, distPath) ? {
+                    return 'auto' === enable ? isDev && !config.dev.writeToDisk ? void 0 : isStrictSubdir(rootPath, distPath) ? {
                         path: distPath,
                         keep
                     } : (rslog_index_js_namespaceObject.logger.warn('The dist path is not a subdir of root path, Rsbuild will not empty it.'), rslog_index_js_namespaceObject.logger.warn(`Please set ${index_js_default().yellow('`output.cleanDistPath`')} config manually.`), rslog_index_js_namespaceObject.logger.warn(`Current root path: ${index_js_default().dim(rootPath)}`), void rslog_index_js_namespaceObject.logger.warn(`Current dist path: ${index_js_default().dim(distPath)}`)) : !0 === enable ? {
@@ -2116,7 +2125,7 @@ var __webpack_exports__ = {};
                     } : void 0;
                 }, cleanAll = async (params)=>{
                     for (let pathInfo of [
-                        ...Object.values(params.environments).reduce((result, curr)=>(result.find((item)=>item.distPath === curr.distPath) || result.push(curr), result), []).map(getPathInfo),
+                        ...Object.values(params.environments).reduce((result, curr)=>(result.find((item)=>item.distPath === curr.distPath) || result.push(curr), result), []).map((environment)=>getPathInfo(environment, params.isDev)),
                         getRsbuildOutputPath()
                     ].filter((pathInfo)=>!!pathInfo))await emptyDir(pathInfo.path, pathInfo.keep);
                 };
@@ -2124,7 +2133,12 @@ var __webpack_exports__ = {};
                     isFirstCompile && await cleanAll({
                         environments
                     });
-                }), api.onBeforeStartDevServer(cleanAll);
+                }), api.onBeforeStartDevServer(async ({ environments })=>{
+                    await cleanAll({
+                        environments,
+                        isDev: !0
+                    });
+                });
             }
         }), dist_isNil = (o)=>null == o, dist_isFunction = (func)=>'function' == typeof func, dist_isObject = (obj)=>null !== obj && 'object' == typeof obj, dist_isPlainObject = (obj)=>dist_isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj);
     function reduceConfigs({ initial, config, mergeFn = Object.assign }) {
@@ -3025,27 +3039,27 @@ var __webpack_exports__ = {};
         apply(compiler) {
             let { splitChunks } = compiler.options.optimization;
             if (!splitChunks) return;
-            let applyPatch = (cacheGroup)=>{
-                if ('object' != typeof cacheGroup || (0, types_namespaceObject.isRegExp)(cacheGroup)) return;
-                let { chunks } = cacheGroup;
+            let applyPatch = (config)=>{
+                if ('object' != typeof config || (0, types_namespaceObject.isRegExp)(config)) return;
+                let { chunks } = config;
                 if (chunks && 'async' !== chunks) {
                     if ('function' == typeof chunks) {
-                        cacheGroup.chunks = (chunk)=>(!chunk.name || chunk.name !== this.name) && chunks(chunk);
+                        config.chunks = (chunk)=>(!chunk.name || chunk.name !== this.name) && chunks(chunk);
                         return;
                     }
                     if ('all' === chunks) {
-                        cacheGroup.chunks = (chunk)=>!chunk.name || chunk.name !== this.name;
+                        config.chunks = (chunk)=>!chunk.name || chunk.name !== this.name;
                         return;
                     }
                     if ('initial' === chunks) {
-                        cacheGroup.chunks = (chunk)=>(!chunk.name || chunk.name !== this.name) && chunk.isOnlyInitial();
+                        config.chunks = (chunk)=>(!chunk.name || chunk.name !== this.name) && chunk.isOnlyInitial();
                         return;
                     }
                 }
             };
             applyPatch(splitChunks);
             let { cacheGroups } = splitChunks;
-            if (cacheGroups) for (let cacheGroupKey of Object.keys(cacheGroups))applyPatch(cacheGroups[cacheGroupKey]);
+            if (cacheGroups) for (let cacheGroupKey of Object.keys(cacheGroups))cacheGroups[cacheGroupKey] && applyPatch(cacheGroups[cacheGroupKey]);
         }
         constructor(name){
             !function(obj, key, value) {
@@ -3227,12 +3241,16 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             detail.family !== familyV4Value || ipv4Interfaces.has(detail.address) || ipv4Interfaces.set(detail.address, detail);
         }
         return Array.from(ipv4Interfaces.values());
-    }, isLoopbackHost = (host)=>[
+    }, isWildcardHost = (host)=>new Set([
+            '0.0.0.0',
+            '::',
+            '0000:0000:0000:0000:0000:0000:0000:0000'
+        ]).has(host), isLoopbackHost = (host)=>new Set([
             'localhost',
             '127.0.0.1',
             '::1',
             '0000:0000:0000:0000:0000:0000:0000:0001'
-        ].includes(host), getHostInUrl = (host)=>host === DEFAULT_DEV_HOST ? 'localhost' : external_node_net_default().isIPv6(host) ? '::' === host ? '[::1]' : `[${host}]` : host, concatUrl = ({ host, port, protocol })=>`${protocol}://${host}:${port}`, LOCAL_LABEL = 'Local:  ', NETWORK_LABEL = 'Network:  ', getUrlLabel = (url)=>{
+        ]).has(host), getHostInUrl = (host)=>host === DEFAULT_DEV_HOST ? 'localhost' : external_node_net_default().isIPv6(host) ? '::' === host ? '[::1]' : `[${host}]` : host, concatUrl = ({ host, port, protocol })=>`${protocol}://${host}:${port}`, LOCAL_LABEL = 'Local:  ', NETWORK_LABEL = 'Network:  ', getUrlLabel = (url)=>{
         try {
             let { host } = new URL(url);
             return isLoopbackHost(host) ? LOCAL_LABEL : NETWORK_LABEL;
@@ -3691,7 +3709,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         return;
                     }
                     try {
-                        module = await import(packagePath);
+                        let moduleURL = 'win32' === process.platform ? (0, external_node_url_namespaceObject.pathToFileURL)(packagePath).href : packagePath;
+                        module = await import(moduleURL);
                     } catch (err) {
                         rslog_index_js_namespaceObject.logger.error(`\`process.env.RSDOCTOR\` enabled, but failed to load ${index_js_default().bold(index_js_default().yellow(packageName))} module.`);
                         return;
@@ -4227,16 +4246,17 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         };
     }
     async function generateRspackConfig({ target, context, environment }) {
-        let chainUtils = getChainUtils(target, context.environments[environment]), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, HotModuleReplacementPlugin } = core_namespaceObject.rspack, rspackConfig = chainToConfig(await modifyBundlerChain(context, {
+        let chainUtils = getChainUtils(target, context.environments[environment]), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, SourceMapDevToolPlugin, HotModuleReplacementPlugin } = core_namespaceObject.rspack, rspackConfig = (await modifyBundlerChain(context, {
             ...chainUtils,
             bundler: {
                 BannerPlugin,
                 DefinePlugin,
                 IgnorePlugin,
                 ProvidePlugin,
+                SourceMapDevToolPlugin,
                 HotModuleReplacementPlugin
             }
-        }));
+        })).toConfig();
         return !function(config) {
             if (config.plugins) {
                 for (let plugin of config.plugins)if (plugin && void 0 === plugin.apply && 'name' in plugin && 'setup' in plugin) {
@@ -4322,6 +4342,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 ])
             })
         };
+    }, validateRsbuildConfig = (config)=>{
+        if (config.server.base && !config.server.base.startsWith('/')) throw Error('[rsbuild:config] The "server.base" option should start with a slash, for example: "/base"');
     };
     async function initRsbuildConfig({ context, pluginManager }) {
         if (context.normalizedConfig) return context.normalizedConfig;
@@ -4359,7 +4381,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 }
                 return common.join(external_node_path_namespaceObject.sep);
             }(distPaths);
-        }(context), context.normalizedConfig;
+        }(context), validateRsbuildConfig(context.normalizedConfig), context.normalizedConfig;
     }
     async function initConfigs({ context, pluginManager, rsbuildOptions }) {
         let normalizedConfig = await initRsbuildConfig({
@@ -4449,6 +4471,31 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             rl.close();
         };
     }
+    let external_node_dns_namespaceObject = require("node:dns");
+    async function getLocalhostResolvedAddress() {
+        let [defaultLookup, explicitLookup] = await Promise.all([
+            external_node_dns_namespaceObject.promises.lookup('localhost'),
+            external_node_dns_namespaceObject.promises.lookup('localhost', {
+                verbatim: !0
+            })
+        ]);
+        return defaultLookup.family === explicitLookup.family && defaultLookup.address === explicitLookup.address ? void 0 : defaultLookup.address;
+    }
+    async function resolveHostname(host = 'localhost') {
+        if ('localhost' === host) {
+            let resolvedAddress = await getLocalhostResolvedAddress();
+            if (resolvedAddress) return resolvedAddress;
+        }
+        return void 0 === host || isWildcardHost(host) ? 'localhost' : host;
+    }
+    async function getResolvedClientConfig(clientConfig, serverConfig) {
+        let resolvedHost = await resolveHostname(serverConfig.host);
+        return {
+            ...clientConfig,
+            host: resolvedHost,
+            port: serverConfig.port
+        };
+    }
     let isClientCompiler = (compiler)=>{
         let { target } = compiler.options;
         return !!target && (Array.isArray(target) ? target.includes('web') : 'web' === target);
@@ -4465,13 +4512,14 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }), 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 (options)=>{
-            let { clientPaths, clientConfig, callbacks, liveReload, ...restOptions } = options;
+        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 = {}, liveReload = !0 }) {
+                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
@@ -4480,6 +4528,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     compiler,
                     clientPaths,
                     clientConfig,
+                    resolvedClientConfig,
                     liveReload
                 }), setupServerHooks(compiler, callbacks);
             }), rsbuildDevMiddleware(multiCompiler, restOptions);
@@ -4818,7 +4867,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
     class CompilerDevMiddleware {
         async init() {
             let devMiddleware = await getDevMiddleware(this.compiler);
-            this.middleware = this.setupDevMiddleware(devMiddleware, this.publicPaths), await this.socketServer.prepare();
+            this.middleware = await this.setupDevMiddleware(devMiddleware, this.publicPaths), await this.socketServer.prepare();
         }
         upgrade(req, sock, head) {
             this.socketServer.upgrade(req, sock, head);
@@ -4840,8 +4889,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 data
             });
         }
-        setupDevMiddleware(devMiddleware, publicPaths) {
-            let { devConfig, serverConfig: { headers, base } } = this, middleware = devMiddleware({
+        async setupDevMiddleware(devMiddleware, publicPaths) {
+            let { devConfig, serverConfig } = this, { headers, base } = serverConfig, 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,
@@ -4863,16 +4916,13 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         this.socketServer.updateStats(stats);
                     }
                 },
-                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),
+                clientPaths: clientPaths,
                 clientConfig: devConfig.client,
                 liveReload: devConfig.liveReload,
                 writeToDisk: devConfig.writeToDisk,
                 serverSideRender: !0,
-                etag: 'weak'
+                etag: 'weak',
+                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)=>{
@@ -5300,7 +5350,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         }(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){
             let proxyMiddleware = baseMiddleware(opts.context, opts), middleware = async (req, res, next)=>{
-                let bypassUrl = 'function' == typeof opts.bypass ? opts.bypass(req, res, opts) : null;
+                let bypassUrl = 'function' == typeof opts.bypass ? await opts.bypass(req, res, opts) : null;
                 !1 === bypassUrl ? (res.statusCode = 404, next()) : 'string' == typeof bypassUrl ? (req.url = bypassUrl, next()) : !0 === bypassUrl ? next() : proxyMiddleware(req, res, next);
             };
             middlewares.push(middleware), opts.ws && proxyMiddlewares.push(proxyMiddleware);
@@ -5960,7 +6010,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             if (isFunction(plugin.apply)) {
                                 let { name = 'SomeWebpackPlugin' } = plugin.constructor || {};
                                 throw Error([
-                                    `${index_js_default().yellow(name)} looks like a Webpack or Rspack plugin, please use ${index_js_default().yellow('`tools.rspack`')} to register it:`,
+                                    `${index_js_default().yellow(name)} looks like a webpack or Rspack plugin, please use ${index_js_default().yellow('`tools.rspack`')} to register it:`,
                                     index_js_default().green(`
   // rsbuild.config.ts
   export default {
@@ -6567,7 +6617,9 @@ ${section.body}` : section.body).join("\n\n"));
         }
     }
     let cac_dist = (name = "")=>new CAC(name), applyCommonOptions = (cli)=>{
-        cli.option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').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', {
+        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', {
             type: [
                 String
             ],
@@ -6588,12 +6640,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.3\n`);
+            (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), rslog_index_js_namespaceObject.logger.greet(`  Rsbuild v1.2.5\n`);
         }();
         try {
             !function() {
                 let cli = cac_dist('rsbuild');
-                cli.help(), cli.version("1.2.3"), applyCommonOptions(cli);
+                cli.help(), cli.version("1.2.5"), 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 {
@@ -6644,7 +6696,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.3";
+    let src_rslib_entry_version = "1.2.5";
 })();
 var __webpack_export_target__ = exports;
 for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];