@rsbuild/core 1.6.3 → 1.6.4

package/dist/index.js

@@ -3030,7 +3030,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
         await onEnvironmentDone(0, stats), await onDone(stats);
     });
 }, 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 isFirstCompile = !0, { environmentList } = context, onDone = async (stats)=>{
         let p = context.hooks.onAfterBuild.callBatch({
             isFirstCompile,
             stats,
@@ -3078,7 +3078,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
         MultiStatsCtor
     });
 }, 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 isFirstCompile = !0, { environmentList } = context, onDone = async (stats)=>{
         let p = context.hooks.onAfterDevCompile.callBatch({
             isFirstCompile,
             stats,
@@ -3185,11 +3185,18 @@ function hintUnknownFiles(message) {
     ])if (plugin.test.test(message)) return message.replace(hint, plugin.hint);
     return message;
 }
-function formatStatsError(stats, verbose) {
-    let message, fileName = resolveFileName(stats), mainMessage = stats.message, details = verbose && stats.details ? `\nDetails: ${stats.details}\n` : '', stack = verbose && stats.stack ? `\n${stats.stack}` : '', moduleTrace = formatModuleTrace(stats, fileName) ?? '';
-    message = `${!fileName ? '' : /:\d+:\d+/.test(fileName) ? `File: ${color.cyan(fileName)}\n` : `File: ${color.cyan(`${fileName}:1:1`)}\n`}${mainMessage}${details}${stack}${moduleTrace}`;
+function formatStatsError(stats) {
+    let fileName = resolveFileName(stats), message = `${!fileName ? '' : /:\d+:\d+/.test(fileName) ? `File: ${color.cyan(fileName)}\n` : stats.loc ? `File: ${color.cyan(`${fileName}:${stats.loc}`)}\n` : `File: ${color.cyan(`${fileName}:1:1`)}\n`}${stats.message}`, verbose = 'verbose' === logger.level;
+    verbose && (stats.details && (message += `\nDetails: ${stats.details}\n`), stats.stack && (message += `\n${stats.stack}`));
+    let moduleTrace = formatModuleTrace(stats, fileName);
+    moduleTrace && (message += moduleTrace);
     let innerError = '-- inner error --';
-    return !verbose && message.includes(innerError) && (message = message.split(innerError)[0]), (message = (message = ((message)=>{
+    !verbose && message.includes(innerError) && (message = message.split(innerError)[0]);
+    let lines = (message = ((message)=>{
+        if (-1 === message.indexOf('Multiple assets emit different content to the same filename')) return message;
+        let extraMessage = `You may need to adjust ${color.yellow('output.filename')} configuration to prevent name conflicts. (See ${color.yellow('https://rsbuild.rs/config/output/filename')})`;
+        return `${message}\n${extraMessage}`;
+    })(message = ((message)=>{
         let getTips = (moduleName)=>{
             let tips = [
                 `Error: "${moduleName}" is a built-in Node.js module and cannot be imported in client-side code.\n`,
@@ -3244,7 +3251,8 @@ function formatStatsError(stats, verbose) {
             'vm',
             'zlib'
         ].includes(moduleName) ? getTips(moduleName) : message;
-    })(message = hintUnknownFiles(message))).split('\n').filter((line, index, arr)=>0 === index || '' !== line.trim() || line.trim() !== arr[index - 1].trim()).join('\n')).trim();
+    })(message = hintUnknownFiles(message)))).split('\n');
+    return (message = (lines = lines.filter((line, index, arr)=>0 === index || '' !== line.trim() || line.trim() !== arr[index - 1].trim())).join('\n')).trim();
 }
 function formatErrorMessage(errors) {
     if (!errors.length) return 'Build failed. No errors reported since Rspack\'s "stats.errors" is disabled.';
@@ -3261,7 +3269,8 @@ function getStatsOptions(compiler, action) {
         timings: !0,
         errors: !0,
         warnings: !0,
-        moduleTrace: !0
+        moduleTrace: !0,
+        errorStack: 'verbose' === logger.level
     };
     if ('dev' === action && (defaultOptions = {
         ...defaultOptions,
@@ -3285,12 +3294,11 @@ function getRsbuildStats(statsInstance, compiler, action) {
     return statsInstance.toJson(statsOptions);
 }
 function formatStats(stats, hasErrors) {
-    let verbose = 'verbose' === logger.level;
     if (hasErrors) return {
-        message: formatErrorMessage(getStatsErrors(stats).map((item)=>formatStatsError(item, verbose))),
+        message: formatErrorMessage(getStatsErrors(stats).map((item)=>formatStatsError(item))),
         level: 'error'
     };
-    let warningMessages = getStatsWarnings(stats).map((item)=>formatStatsError(item, verbose));
+    let warningMessages = getStatsWarnings(stats).map((item)=>formatStatsError(item));
     if (warningMessages.length) {
         let title = color.bold(color.yellow(warningMessages.length > 1 ? 'Build warnings: \n' : 'Build warning: \n'));
         return {
@@ -3534,8 +3542,8 @@ let OVERRIDE_PATHS = new Set([
         dev.watchFiles
     ]), normalizedConfig.dev = dev), normalizedConfig;
 }, mergeRsbuildConfig = (...originalConfigs)=>{
-    let configs = originalConfigs.map(normalizeConfigStructure);
-    return 2 === configs.length ? merge(configs[0], configs[1]) : configs.length < 2 ? configs[0] : configs.reduce((result, config)=>merge(result, config), {});
+    let configs = originalConfigs.filter((config)=>void 0 !== config).map(normalizeConfigStructure);
+    return 2 === configs.length ? merge(configs[0], configs[1]) : 1 === configs.length ? configs[0] : 0 === configs.length ? {} : configs.reduce((result, config)=>merge(result, config), {});
 }, defaultConfig_require = (0, external_node_module_.createRequire)(import.meta.url), defaultAllowedOrigins = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/, createDefaultConfig = ()=>({
         dev: {
             hmr: !0,
@@ -4114,15 +4122,15 @@ async function updateEnvironmentContext(context, configs) {
             tsconfigPath,
             config,
             webSocketToken
-        };
-        context.environments[name] = new Proxy(environmentContext, {
+        }, readonlyEnvironmentContext = new Proxy(environmentContext, {
             get: (target, prop)=>target[prop],
             set: (target, prop, newValue)=>('manifest' === prop ? target[prop] = newValue : logger.error(`EnvironmentContext is readonly, you can not assign to the "environment.${prop}" prop.`), !0)
         });
+        context.environmentList[index] = readonlyEnvironmentContext, context.environments[name] = readonlyEnvironmentContext;
     }
 }
 function updateContextByNormalizedConfig(context) {
-    let distPaths = Object.values(context.environments).map((item)=>item.distPath);
+    let distPaths = context.environmentList.map((item)=>item.distPath);
     context.distPath = getCommonParentPath(distPaths);
 }
 function createPublicContext(context) {
@@ -4146,13 +4154,14 @@ 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, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
     return {
-        version: "1.6.3",
+        version: "1.6.4",
         rootPath,
         distPath: '',
         cachePath,
         callerName: options.callerName,
         bundlerType,
         environments: {},
+        environmentList: [],
         publicPathnames: [],
         hooks: initHooks(),
         config: {
@@ -4454,10 +4463,11 @@ function getConfigUtils(getCurrentConfig, chainUtils) {
         }
     };
 }
-function getChainUtils(target, environment) {
+function getChainUtils(target, environment, environments) {
     return {
         rspack: rspack_rspack,
         environment,
+        environments,
         env: process.env.NODE_ENV || '',
         target,
         isDev: 'development' === environment.config.mode,
@@ -4477,8 +4487,8 @@ function validateRspackConfig(config) {
     }
     config.devServer && logger.warn(`${color.dim('[rsbuild:config]')} Find invalid Rspack config: "${color.yellow('devServer')}". Note that Rspack's "devServer" config is not supported by Rsbuild. You can use Rsbuild's "dev" config to configure the Rsbuild dev server.`);
 }
-async function generateRspackConfig({ target, context, environment }) {
-    let chainUtils = getChainUtils(target, context.environments[environment]), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, SourceMapDevToolPlugin, HotModuleReplacementPlugin } = rspack_rspack, rspackConfig = (await modifyBundlerChain(context, {
+async function generateRspackConfig({ target, context, environmentName }) {
+    let chainUtils = getChainUtils(target, context.environments[environmentName], context.environments), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, SourceMapDevToolPlugin, HotModuleReplacementPlugin } = rspack_rspack, rspackConfig = (await modifyBundlerChain(context, {
         ...chainUtils,
         bundler: {
             BannerPlugin,
@@ -4627,10 +4637,10 @@ async function initConfigs({ context, pluginManager, rsbuildOptions }) {
     let normalizedConfig = await initRsbuildConfig({
         context,
         pluginManager
-    }), rspackConfigs = await Promise.all(Object.entries(normalizedConfig.environments).map(([environment, config])=>generateRspackConfig({
+    }), rspackConfigs = await Promise.all(Object.entries(normalizedConfig.environments).map(([environmentName, config])=>generateRspackConfig({
             target: config.output.target,
             context,
-            environment
+            environmentName
         })));
     if (isDebug()) {
         let inspect = async ()=>{
@@ -4734,8 +4744,8 @@ async function createCompiler_createCompiler(options) {
                 logger.ready(`built in ${time}${suffix}`);
             }
         };
-        hasErrors || (isMultiCompiler && stats.children?.length ? stats.children.forEach((c, index)=>{
-            printTime(c, index);
+        hasErrors || (isMultiCompiler && stats.children?.length ? stats.children.forEach((item, index)=>{
+            printTime(item, index);
         }) : printTime(stats, 0));
         let { message, level } = formatStats(stats, hasErrors);
         'error' === level && logger.error(message), 'warning' === level && logger.warn(message), isCompiling = !1;
@@ -5450,7 +5460,7 @@ let getInlineTests = (config)=>{
     let trailingSlashBase = addTrailingSlash(base);
     return path.startsWith(trailingSlashBase) ? path.slice(trailingSlashBase.length - 1) : path;
 }, getRoutes = (context)=>{
-    let environmentWithHtml = Object.values(context.environments).filter((item)=>Object.keys(item.htmlPaths).length > 0);
+    let environmentWithHtml = context.environmentList.filter((item)=>Object.keys(item.htmlPaths).length > 0);
     if (0 === environmentWithHtml.length) return [];
     let commonDistPath = getCommonParentPath(environmentWithHtml.map((item)=>item.distPath));
     return environmentWithHtml.reduce((prev, environmentContext)=>{
@@ -6195,7 +6205,7 @@ async function getFileFromUrl(url, outputFileSystem, context) {
             outputFileSystem.stat(filename, (err, stats)=>{
                 err ? reject(err) : resolve(stats);
             });
-        }), { environments, publicPathnames } = context, distPaths = Object.values(environments).map((env)=>env.distPath), possibleFilenames = new Set();
+        }), { environmentList, publicPathnames } = context, distPaths = environmentList.map((env)=>env.distPath), possibleFilenames = new Set();
     for (let [index, distPath] of distPaths.entries()){
         let prefix = publicPathnames[index];
         prefix && '/' !== prefix && pathname.startsWith(prefix) && possibleFilenames.add(external_node_path_.default.join(distPath, pathname.slice(prefix.length)));
@@ -6519,9 +6529,9 @@ function applyHMREntry({ config, compiler, token, resolvedHost, resolvedPort })
 }
 let assets_middleware_assetsMiddleware = async ({ config, compiler, context, socketServer, resolvedPort })=>{
     var config1;
-    let watching, writeToDiskValues, resolvedHost = await resolveHostname(config.server.host), { environments } = context;
+    let watching, writeToDiskValues, resolvedHost = await resolveHostname(config.server.host), { environments, environmentList } = context;
     applyToCompiler(compiler, (compiler, index)=>{
-        let environment = Object.values(environments).find((env)=>env.index === index);
+        let environment = environmentList[index];
         if (!environment) return;
         let token = environment.webSocketToken;
         token && (applyHMREntry({
@@ -6575,7 +6585,7 @@ let assets_middleware_assetsMiddleware = async ({ config, compiler, context, soc
             }), callbacks.length = 0);
         });
     });
-    let writeToDisk = (config1 = config.dev, 1 === new Set(writeToDiskValues = Object.values(environments).map((env)=>env.config.dev.writeToDisk)).size ? writeToDiskValues[0] : (filePath, name)=>{
+    let writeToDisk = (config1 = config.dev, 1 === new Set(writeToDiskValues = environmentList.map((env)=>env.config.dev.writeToDisk)).size ? writeToDiskValues[0] : (filePath, name)=>{
         let { writeToDisk } = config1;
         return name && environments[name] && (writeToDisk = environments[name].config.dev.writeToDisk ?? writeToDisk), 'function' == typeof writeToDisk ? writeToDisk(filePath) : writeToDisk;
     });
@@ -6953,7 +6963,7 @@ class SocketServer {
     upgrade = (req, socket, head)=>{
         if (!this.wsServer.shouldHandle(req)) return;
         let query = parseQueryString(req);
-        Object.values(this.context.environments).map((env)=>env.webSocketToken).includes(query.token) ? this.wsServer.handleUpgrade(req, socket, head, (connection)=>{
+        this.context.environmentList.map(({ webSocketToken })=>webSocketToken).includes(query.token) ? this.wsServer.handleUpgrade(req, socket, head, (connection)=>{
             this.wsServer.emit('connection', connection, req);
         }) : socket.destroy();
     };
@@ -7034,7 +7044,7 @@ class SocketServer {
         });
     }
     getStats(token) {
-        let { stats } = this.context.buildState, environment = Object.values(this.context.environments).find(({ webSocketToken })=>webSocketToken === token);
+        let { stats } = this.context.buildState, environment = this.context.environmentList.find(({ webSocketToken })=>webSocketToken === token);
         if (!stats || !environment) return;
         let currentStats = stats;
         if (stats.children) {
@@ -7765,30 +7775,31 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             if (!htmlPath) throw Error(`${color.dim('[rsbuild:getTransformedHtml]')} Failed to get HTML file by entryName: ${color.yellow(entryName)}`);
             let fileName = (0, external_node_path_.join)(distPath, htmlPath);
             return utils.readFileSync(fileName);
-        })(entryName, utils)), environmentAPI = Object.fromEntries(Object.entries(context.environments).map(([name, environment])=>[
-            name,
-            {
-                getStats: async ()=>{
-                    if (!buildManager) throw Error(`${color.dim('[rsbuild:server]')} Can not call ${color.yellow('getStats')} when ${color.yellow('runCompile')} is false`);
-                    return await waitLastCompileDone, lastStats[environment.index];
-                },
-                context: environment,
-                loadBundle: async (entryName)=>{
-                    if (!buildManager) throw Error(`${color.dim('[rsbuild:server]')} Can not call ${color.yellow('loadBundle')} when ${color.yellow('runCompile')} is false`);
-                    return await waitLastCompileDone, cacheableLoadBundle(lastStats[environment.index], entryName, {
-                        readFileSync: buildManager.readFileSync,
-                        environment
-                    });
-                },
-                getTransformedHtml: async (entryName)=>{
-                    if (!buildManager) throw Error(`${color.dim('[rsbuild:server]')} Can not call ${color.yellow('getTransformedHtml')} when ${color.yellow('runCompile')} is false`);
-                    return await waitLastCompileDone, cacheableTransformedHtml(lastStats[environment.index], entryName, {
-                        readFileSync: buildManager.readFileSync,
-                        environment
-                    });
-                }
+        })(entryName, utils)), environmentAPI = {}, getErrorMsg = (method)=>`${color.dim('[rsbuild:server]')} Can not call ${color.yellow(method)} when ${color.yellow('runCompile')} is false`;
+    context.environmentList.forEach((environment, index)=>{
+        environmentAPI[environment.name] = {
+            context: environment,
+            getStats: async ()=>{
+                if (!buildManager) throw Error(getErrorMsg('getStats'));
+                return await waitLastCompileDone, lastStats[index];
+            },
+            loadBundle: async (entryName)=>{
+                if (!buildManager) throw Error(getErrorMsg('loadBundle'));
+                return await waitLastCompileDone, cacheableLoadBundle(lastStats[index], entryName, {
+                    readFileSync: buildManager.readFileSync,
+                    environment
+                });
+            },
+            getTransformedHtml: async (entryName)=>{
+                if (!buildManager) throw Error(getErrorMsg('getTransformedHtml'));
+                return await waitLastCompileDone, cacheableTransformedHtml(lastStats[index], entryName, {
+                    readFileSync: buildManager.readFileSync,
+                    environment
+                });
             }
-        ])), middlewares = requireCompiledPackage('connect')(), httpServer = middlewareMode ? null : await createHttpServer({
+        };
+    });
+    let middlewares = requireCompiledPackage('connect')(), httpServer = middlewareMode ? null : await createHttpServer({
         serverConfig: config.server,
         middlewares
     }), devServerAPI = {
@@ -8125,7 +8136,7 @@ class RsbuildProdServer {
             ],
             single: 'index' === htmlFallback
         });
-        this.middlewares.use((req, res, next)=>{
+        this.middlewares.use(function staticAssetMiddleware(req, res, next) {
             let url = req.url, 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);
@@ -8141,7 +8152,7 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
         pwd: context.rootPath,
         output: {
             path: context.distPath,
-            assetPrefixes: Object.values(context.environments).map((e)=>getPathnameFromUrl(e.config.output.assetPrefix))
+            assetPrefixes: context.environmentList.map((e)=>getPathnameFromUrl(e.config.output.assetPrefix))
         },
         serverConfig
     }, middlewares);
@@ -8806,7 +8817,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 let postcssrcCache = new Map();
                 api.modifyBundlerChain({
                     order: 'pre',
-                    handler: async (chain, { target, isProd, CHAIN_ID, environment })=>{
+                    handler: async (chain, { target, isProd, CHAIN_ID, environment, environments })=>{
                         let rule = chain.module.rule(CHAIN_ID.RULE.CSS), inlineRule = chain.module.rule(CHAIN_ID.RULE.CSS_INLINE), { config } = environment;
                         rule.test(CSS_REGEX).type("javascript/auto").dependency({
                             not: 'url'
@@ -8825,34 +8836,43 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             rule.use(CHAIN_ID.USE.STYLE).loader(getCompiledPath('style-loader')).options(styleLoaderOptions);
                         } else rule.use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader((cssExtractPlugin || rspack_rspack.CssExtractRspackPlugin).loader).options(config.tools.cssExtract.loaderOptions);
                         else rule.use(CHAIN_ID.USE.IGNORE_CSS).loader(external_node_path_.default.join(LOADER_PATH, 'ignoreCssLoader.mjs'));
-                        let importLoaders = 0, updateRules = (callback)=>{
-                            callback(rule, 'normal'), callback(inlineRule, 'inline');
+                        let importLoaders = {
+                            normal: 0,
+                            inline: 0
+                        }, updateRules = (callback, options = {})=>{
+                            options.skipNormal || callback(rule, 'normal'), callback(inlineRule, 'inline');
                         }, cssLoaderPath = getCompiledPath('css-loader');
                         if (updateRules((rule)=>{
                             rule.use(CHAIN_ID.USE.CSS).loader(cssLoaderPath);
-                        }), emitCss) {
-                            if ('rspack' === api.context.bundlerType && !1 !== config.tools.lightningcssLoader) {
-                                importLoaders++;
-                                let { minifyCss } = parseMinifyOptions(config);
-                                updateRules((rule, type)=>{
-                                    let inlineStyle = 'inline' === type || config.output.injectStyles, lightningcssOptions = getLightningCSSLoaderOptions(config, environment.browserslist, inlineStyle && minifyCss);
-                                    rule.use(CHAIN_ID.USE.LIGHTNINGCSS).loader('builtin:lightningcss-loader').options(lightningcssOptions);
-                                });
+                        }), 'rspack' === api.context.bundlerType && !1 !== config.tools.lightningcssLoader) {
+                            emitCss && importLoaders.normal++, importLoaders.inline++;
+                            let { minifyCss } = parseMinifyOptions(config), { browserslist } = environment;
+                            if ('node' === target) {
+                                let webEnvironment = Object.values(environments).find((env)=>'web' === env.config.output.target);
+                                webEnvironment?.browserslist && (browserslist = webEnvironment.browserslist);
                             }
-                            let postcssLoaderOptions = await getPostcssLoaderOptions({
-                                config,
-                                root: api.context.rootPath,
-                                postcssrcCache
+                            updateRules((rule, type)=>{
+                                let inlineStyle = 'inline' === type || config.output.injectStyles, lightningcssOptions = getLightningCSSLoaderOptions(config, browserslist, inlineStyle && minifyCss);
+                                rule.use(CHAIN_ID.USE.LIGHTNINGCSS).loader('builtin:lightningcss-loader').options(lightningcssOptions);
+                            }, {
+                                skipNormal: !emitCss
                             });
-                            if ('function' == typeof postcssLoaderOptions.postcssOptions || postcssLoaderOptions.postcssOptions?.plugins?.length) {
-                                importLoaders++;
-                                let postcssLoaderPath = getCompiledPath('postcss-loader');
-                                updateRules((rule)=>{
-                                    rule.use(CHAIN_ID.USE.POSTCSS).loader(postcssLoaderPath).options(postcssLoaderOptions);
-                                });
-                            }
                         }
-                        let localIdentName = config.output.cssModules.localIdentName || (isProd ? '[local]-[hash:base64:6]' : '[path][name]__[local]-[hash:base64:6]'), cssLoaderOptions = (({ config, importLoaders, localIdentName, emitCss })=>{
+                        let postcssLoaderOptions = await getPostcssLoaderOptions({
+                            config,
+                            root: api.context.rootPath,
+                            postcssrcCache
+                        });
+                        if ('function' == typeof postcssLoaderOptions.postcssOptions || postcssLoaderOptions.postcssOptions?.plugins?.length) {
+                            emitCss && importLoaders.normal++, importLoaders.inline++;
+                            let postcssLoaderPath = getCompiledPath('postcss-loader');
+                            updateRules((rule)=>{
+                                rule.use(CHAIN_ID.USE.POSTCSS).loader(postcssLoaderPath).options(postcssLoaderOptions);
+                            }, {
+                                skipNormal: !emitCss
+                            });
+                        }
+                        let localIdentName = config.output.cssModules.localIdentName || (isProd ? '[local]-[hash:base64:6]' : '[path][name]__[local]-[hash:base64:6]'), cssLoaderOptions = (({ config, localIdentName, emitCss })=>{
                             let { cssModules } = config.output;
                             return ((options, exportOnlyLocals)=>{
                                 if (options.modules && exportOnlyLocals) {
@@ -8873,7 +8893,6 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                 return options;
                             })(reduceConfigs({
                                 initial: {
-                                    importLoaders,
                                     modules: {
                                         ...cssModules,
                                         localIdentName
@@ -8885,16 +8904,20 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             }), !emitCss);
                         })({
                             config,
-                            importLoaders,
                             localIdentName,
                             emitCss
                         });
                         updateRules((rule, type)=>{
-                            rule.use(CHAIN_ID.USE.CSS).options('inline' === type ? {
+                            let finalOptions = cssLoaderOptions;
+                            finalOptions = 'inline' === type ? {
                                 ...cssLoaderOptions,
                                 exportType: 'string',
-                                modules: !1
-                            } : cssLoaderOptions), rule.sideEffects(!0), rule.resolve.preferRelative(!0);
+                                modules: !1,
+                                importLoaders: importLoaders.inline
+                            } : {
+                                ...cssLoaderOptions,
+                                importLoaders: importLoaders.normal
+                            }, rule.use(CHAIN_ID.USE.CSS).options(finalOptions), rule.sideEffects(!0), rule.resolve.preferRelative(!0);
                         });
                         let isStringExport = 'string' === cssLoaderOptions.exportType;
                         if (isStringExport && rule.uses.has(CHAIN_ID.USE.MINI_CSS_EXTRACT) && rule.uses.delete(CHAIN_ID.USE.MINI_CSS_EXTRACT), emitCss && !config.output.injectStyles && !isStringExport) {
@@ -9452,10 +9475,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             name: 'rsbuild:nonce',
             setup (api) {
                 api.onAfterCreateCompiler(({ compiler, environments })=>{
-                    let environmentList = Object.values(environments), nonces = environmentList.map((environment)=>{
-                        let { nonce } = environment.config.security;
-                        return nonce;
-                    });
+                    let environmentList = Object.values(environments), nonces = Object.values(environments).map((environment)=>environment.config.security.nonce);
                     nonces.some((nonce)=>!!nonce) && applyToCompiler(compiler, (compiler, index)=>{
                         let nonce = nonces[index], environment = environmentList.find((item)=>item.index === index);
                         if (!Object.keys(environment?.htmlPaths ?? {}).length || !nonce) return;
@@ -9781,7 +9801,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands() {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("1.6.3"), 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("1.6.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)', {
         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: [
@@ -9850,7 +9870,7 @@ function initNodeEnv() {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v1.6.3\n`);
+    logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v1.6.4\n`);
 }
 function setupLogLevel() {
     let logLevelIndex = process.argv.findIndex((item)=>'--log-level' === item || '--logLevel' === item);
@@ -9871,7 +9891,7 @@ function runCLI() {
         logger.error('Failed to start Rsbuild CLI.'), logger.error(err);
     }
 }
-let src_version = "1.6.3";
+let src_version = "1.6.4";
 import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
 import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
 import * as __WEBPACK_EXTERNAL_MODULE_node_module_ab9f2194__ from "node:module";

package/dist-types/helpers/format.d.ts

@@ -1,2 +1,2 @@
 import type { StatsError } from '@rspack/core';
-export declare function formatStatsError(stats: StatsError, verbose?: boolean): string;
+export declare function formatStatsError(stats: StatsError): string;

package/dist-types/mergeConfig.d.ts

@@ -1,2 +1,2 @@
 import type { RsbuildConfig } from './types';
-export declare const mergeRsbuildConfig: <T = RsbuildConfig>(...originalConfigs: T[]) => T;
+export declare const mergeRsbuildConfig: <T = RsbuildConfig>(...originalConfigs: (T | undefined)[]) => T;

package/dist-types/provider/rspackConfig.d.ts

@@ -1,8 +1,8 @@
 import type { EnvironmentContext, InternalContext, ModifyChainUtils, ModifyRspackConfigUtils, RsbuildTarget, Rspack } from '../types';
 export declare function getConfigUtils(getCurrentConfig: () => Rspack.Configuration, chainUtils: ModifyChainUtils): ModifyRspackConfigUtils;
-export declare function getChainUtils(target: RsbuildTarget, environment: EnvironmentContext): ModifyChainUtils;
-export declare function generateRspackConfig({ target, context, environment, }: {
-    environment: string;
+export declare function getChainUtils(target: RsbuildTarget, environment: EnvironmentContext, environments: Record<string, EnvironmentContext>): ModifyChainUtils;
+export declare function generateRspackConfig({ target, context, environmentName, }: {
     target: RsbuildTarget;
     context: InternalContext;
+    environmentName: string;
 }): Promise<Rspack.Configuration>;

package/dist-types/server/assets-middleware/setupWriteToDisk.d.ts

@@ -11,5 +11,5 @@ export type ResolvedWriteToDisk = boolean | ((filePath: string, name?: string) =
  * Returns the unified config if all environments have the same value,
  * otherwise returns a function that resolves config based on compilation.
  */
-export declare const resolveWriteToDiskConfig: (config: NormalizedDevConfig, environments: Record<string, EnvironmentContext>) => ResolvedWriteToDisk;
+export declare const resolveWriteToDiskConfig: (config: NormalizedDevConfig, environments: Record<string, EnvironmentContext>, environmentList: EnvironmentContext[]) => ResolvedWriteToDisk;
 export declare function setupWriteToDisk(compilers: Compiler[], writeToDisk: ResolvedWriteToDisk): void;

package/dist-types/types/config.d.ts

@@ -411,7 +411,15 @@ export interface ServerConfig {
      * - object: enable CORS with the specified options.
      * - true: enable CORS with default options (allow all origins, not recommended).
      * - false: disable CORS.
-     * @default false
+     * @default
+     * ```js
+     * { origin: defaultAllowedOrigins }
+     * ```
+     * where `defaultAllowedOrigins` includes:
+     * - `localhost`
+     * - `127.0.0.1`
+     * - `[::1]`
+     *
      * @link https://github.com/expressjs/cors
      */
     cors?: boolean | cors.CorsOptions;

package/dist-types/types/context.d.ts

@@ -90,8 +90,10 @@ export type InternalContext = RsbuildContext & {
      * can be used in all environments.
      */
     getPluginAPI?: (environment?: string) => RsbuildPluginAPI;
-    /** The environment context. */
+    /** Context information for all environments. */
     environments: Record<string, EnvironmentContext>;
+    /** Array of all environments. */
+    environmentList: EnvironmentContext[];
     /** Only build specified environment. */
     specifiedEnvironments?: string[];
     /** Build state information */

package/dist-types/types/hooks.d.ts

@@ -17,10 +17,16 @@ export type OnBeforeEnvironmentCompileFn<B = 'rspack'> = (params: CompileCommonP
 }) => MaybePromise<void>;
 export type OnCloseBuildFn = () => MaybePromise<void>;
 export type OnBeforeBuildFn<B = 'rspack'> = (params: CompileCommonParams & {
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
     bundlerConfigs?: B extends 'rspack' ? Rspack.Configuration[] : WebpackConfig[];
 }) => MaybePromise<void>;
 export type OnBeforeDevCompileFn<B = 'rspack'> = (params: CompileCommonParams & {
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
     bundlerConfigs?: B extends 'rspack' ? Rspack.Configuration[] : WebpackConfig[];
 }) => MaybePromise<void>;
@@ -30,12 +36,18 @@ export type OnAfterEnvironmentCompileFn = (params: CompileCommonParams & {
 }) => MaybePromise<void>;
 export type OnAfterBuildFn = (params: CompileCommonParams & {
     stats?: Rspack.Stats | Rspack.MultiStats;
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnCloseDevServerFn = () => MaybePromise<void>;
 export type OnAfterDevCompileFn = (params: {
     isFirstCompile: boolean;
     stats: Rspack.Stats | Rspack.MultiStats;
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 /**
@@ -48,7 +60,7 @@ export type OnBeforeStartDevServerFn = (params: {
      */
     server: RsbuildDevServer;
     /**
-     * A read-only object that provides some context information about different environments.
+     * Context information for all environments.
      */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<(() => void) | void>;
@@ -60,19 +72,31 @@ export type Routes = {
 export type OnAfterStartDevServerFn = (params: {
     port: number;
     routes: Routes;
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnAfterStartProdServerFn = (params: {
     port: number;
     routes: Routes;
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnBeforeCreateCompilerFn<B = 'rspack'> = (params: {
     bundlerConfigs: B extends 'rspack' ? Rspack.Configuration[] : WebpackConfig[];
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnAfterCreateCompilerFn<Compiler = Rspack.Compiler | Rspack.MultiCompiler> = (params: {
     compiler: Compiler;
+    /**
+     * Context information for all environments.
+     */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnExitFn = (context: {
@@ -124,6 +148,9 @@ export type ModifyEnvironmentConfigUtils = {
 export type ModifyRsbuildConfigFn = (config: RsbuildConfig, utils: ModifyRsbuildConfigUtils) => MaybePromise<RsbuildConfig | void>;
 export type ModifyEnvironmentConfigFn = (config: MergedEnvironmentConfig, utils: ModifyEnvironmentConfigUtils) => MaybePromise<MergedEnvironmentConfig | void>;
 export type EnvironmentContext = {
+    /**
+     * The index of the current environment.
+     */
     index: number;
     /**
      * The unique name of the current environment is used to distinguish and locate the
@@ -209,6 +236,10 @@ export type ModifyChainUtils = {
      * The environment context for current build.
      */
     environment: EnvironmentContext;
+    /**
+     * Context information for all environments.
+     */
+    environments: Record<string, EnvironmentContext>;
     /**
      * The Rspack instance, same as `import { rspack } from '@rsbuild/core'`.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {
@@ -46,7 +46,7 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "1.6.1",
+    "@rspack/core": "1.6.2",
     "@rspack/lite-tapable": "~1.0.1",
     "@swc/helpers": "^0.5.17",
     "core-js": "~3.46.0",