@rsbuild/core 1.4.2 → 1.4.4

package/dist/index.js

@@ -8,7 +8,7 @@ import picocolors from "../compiled/picocolors/index.js";
 import node_fs, { existsSync } from "node:fs";
 import { EventEmitter } from "events";
 import { createRequire } from "node:module";
-import node_os, { constants } from "node:os";
+import node_os, { constants as external_node_os_constants } from "node:os";
 import node_process from "node:process";
 import rspack_chain from "../compiled/rspack-chain/index.js";
 import { isPromise, isRegExp } from "node:util/types";
@@ -777,7 +777,7 @@ let constants_filename = fileURLToPath(import.meta.url), constants_dirname = dir
     node: [
         'node >= 16'
     ]
-}, HTML_REGEX = /\.html$/, JS_REGEX = /\.(?:js|mjs|cjs|jsx)$/, SCRIPT_REGEX = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/, CSS_REGEX = /\.css$/, NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/, PLUGIN_SWC_NAME = 'rsbuild:swc', PLUGIN_CSS_NAME = 'rsbuild:css', FONT_EXTENSIONS = [
+}, HTML_REGEX = /\.html$/, JS_REGEX = /\.(?:js|mjs|cjs|jsx)$/, SCRIPT_REGEX = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/, CSS_REGEX = /\.css$/, RAW_QUERY_REGEX = /^\?raw$/, INLINE_QUERY_REGEX = /^\?inline$/, NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/, PLUGIN_SWC_NAME = 'rsbuild:swc', PLUGIN_CSS_NAME = 'rsbuild:css', FONT_EXTENSIONS = [
     'woff',
     'woff2',
     'eot',
@@ -2040,7 +2040,7 @@ let getEnvironmentHTMLPaths = (entry, config)=>'web' !== config.output.target ||
     }, {});
 async function updateEnvironmentContext(context, configs) {
     for (let [index, [name, config]] of (context.environments ||= {}, Object.entries(configs).entries())){
-        let browserslist = await getBrowserslistByEnvironment(context.rootPath, config), { entry = {}, tsconfigPath } = config.source, htmlPaths = getEnvironmentHTMLPaths(entry, config), environmentContext = {
+        let browserslist = await getBrowserslistByEnvironment(context.rootPath, config), { entry = {}, tsconfigPath } = config.source, htmlPaths = getEnvironmentHTMLPaths(entry, config), webSocketToken = 'dev' === context.action ? await helpers_hash(context.rootPath + name) : '', environmentContext = {
             index,
             name,
             distPath: function(cwd, config) {
@@ -2051,7 +2051,8 @@ async function updateEnvironmentContext(context, configs) {
             browserslist,
             htmlPaths,
             tsconfigPath,
-            config
+            config,
+            webSocketToken
         };
         context.environments[name] = new Proxy(environmentContext, {
             get: (target, prop)=>target[prop],
@@ -2062,7 +2063,7 @@ async function updateEnvironmentContext(context, configs) {
 async function createContext(options, userConfig) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
     return {
-        version: "1.4.2",
+        version: "1.4.4",
         rootPath,
         distPath: '',
         cachePath,
@@ -2751,7 +2752,7 @@ let chainStaticAssetRule = ({ emit, rule, maxSize, filename, assetType })=>{
     let generatorOptions = {
         filename
     };
-    !1 === emit && (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(/(__inline=false|url)/).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(/inline/), rule.oneOf(`${assetType}-asset-raw`).type('asset/source').resourceQuery(/raw/), rule.oneOf(`${assetType}-asset`).type('asset').parser({
+    !1 === emit && (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(/^\?(__inline=false|url)$/).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(INLINE_QUERY_REGEX), rule.oneOf(`${assetType}-asset-raw`).type('asset/source').resourceQuery(RAW_QUERY_REGEX), rule.oneOf(`${assetType}-asset`).type('asset').parser({
         dataUrlCondition: {
             maxSize
         }
@@ -3685,9 +3686,6 @@ let getPort = async ({ host, port, strictPort, tryLimits = 20 })=>{
         })
     });
     return addressUrls;
-}, COMPILATION_ID_REGEX = /[^a-zA-Z0-9_-]/g, getCompilationId = (compiler)=>{
-    let uniqueName = compiler.options.output.uniqueName ?? '';
-    return `${compiler.name ?? ''}_${uniqueName.replace(COMPILATION_ID_REGEX, '_')}`;
 };
 function getServerTerminator(server) {
     let listened = !1, pendingSockets = new Set(), onConnection = (socket)=>{
@@ -3751,6 +3749,7 @@ async function openBrowser(url) {
 }
 let openedURLs = [], replacePortPlaceholder = (url, port)=>url.replace(/<port>/g, String(port));
 async function server_open_open({ https, port, routes, config, clearCache }) {
+    if ('true' === process.env.CSB) return;
     let { targets, before } = ((config)=>{
         let { open } = config.server;
         return 'boolean' == typeof open ? {
@@ -4154,13 +4153,15 @@ async function getResolvedClientConfig(clientConfig, serverConfig) {
 }
 let getCompilationMiddleware = async (compiler, options)=>{
     let { default: rsbuildDevMiddleware } = await import("../compiled/rsbuild-dev-middleware/index.js"), { clientPaths, callbacks, devConfig, serverConfig } = options, resolvedClientConfig = await getResolvedClientConfig(devConfig.client, serverConfig);
-    return applyToCompiler(compiler, (compiler)=>{
-        clientPaths && function({ compiler, clientPaths, devConfig, resolvedClientConfig }) {
+    return applyToCompiler(compiler, (compiler, index)=>{
+        var _Object_values_find;
+        let token = null == (_Object_values_find = Object.values(options.environments).find((env)=>env.index === index)) ? void 0 : _Object_values_find.webSocketToken;
+        token && (clientPaths && function({ compiler, clientPaths, devConfig, resolvedClientConfig, token }) {
             if (((compiler)=>{
                 let { target } = compiler.options;
                 return !!target && (Array.isArray(target) ? target.includes('web') : 'web' === target);
             })(compiler)) for (let clientPath of (new compiler.webpack.DefinePlugin({
-                RSBUILD_COMPILATION_NAME: JSON.stringify(getCompilationId(compiler)),
+                RSBUILD_WEB_SOCKET_TOKEN: JSON.stringify(token),
                 RSBUILD_CLIENT_CONFIG: JSON.stringify(devConfig.client),
                 RSBUILD_RESOLVED_CLIENT_CONFIG: JSON.stringify(resolvedClientConfig),
                 RSBUILD_DEV_LIVE_RELOAD: devConfig.liveReload
@@ -4171,19 +4172,26 @@ let getCompilationMiddleware = async (compiler, options)=>{
             compiler,
             clientPaths,
             devConfig,
-            resolvedClientConfig
-        }), ((compiler, { onDone, onInvalid })=>{
+            resolvedClientConfig,
+            token
+        }), (({ compiler, token, callbacks: { onDone, onInvalid } })=>{
             if (((compiler)=>{
                 let { target } = compiler.options;
                 return !!target && (Array.isArray(target) ? target.includes('node') : 'node' === target);
             })(compiler)) return;
             let { compile, invalid, done } = compiler.hooks;
             compile.tap('rsbuild-dev-server', ()=>{
-                onInvalid(getCompilationId(compiler));
+                onInvalid(token);
             }), invalid.tap('rsbuild-dev-server', (fileName)=>{
-                onInvalid(getCompilationId(compiler), fileName);
-            }), done.tap('rsbuild-dev-server', onDone);
-        })(compiler, callbacks);
+                onInvalid(token, fileName);
+            }), done.tap('rsbuild-dev-server', (stats)=>{
+                onDone(token, stats);
+            });
+        })({
+            compiler,
+            callbacks,
+            token
+        }));
     }), rsbuildDevMiddleware(compiler, {
         etag: 'weak',
         publicPath: '/',
@@ -4229,6 +4237,10 @@ function socketServer_define_property(obj, key, value) {
         writable: !0
     }) : obj[key] = value, obj;
 }
+let parseQueryString = (req)=>{
+    let queryStr = req.url ? req.url.split('?')[1] : '';
+    return queryStr ? Object.fromEntries(new URLSearchParams(queryStr)) : {};
+};
 class SocketServer {
     clearHeartbeatTimer() {
         this.heartbeatTimer && (clearTimeout(this.heartbeatTimer), this.heartbeatTimer = null);
@@ -4243,51 +4255,44 @@ class SocketServer {
         }), this.wsServer.on('error', (err)=>{
             logger.error(err);
         }), this.heartbeatTimer = setTimeout(this.checkSockets, 30000).unref(), this.wsServer.on('connection', (socket, req)=>{
-            let queryStr = req.url ? req.url.split('?')[1] : '';
-            this.onConnect(socket, queryStr ? Object.fromEntries(new URLSearchParams(queryStr)) : {});
+            let query = parseQueryString(req);
+            this.onConnect(socket, query.token);
         });
     }
-    updateStats(stats) {
-        let compilationId = getCompilationId(stats.compilation);
-        this.stats[compilationId] = stats, this.sockets.length && this.sendStats({
-            compilationId
+    updateStats(stats, token) {
+        this.stats[token] = stats, this.sockets.size && this.sendStats({
+            token
         });
     }
-    sockWrite({ type, compilationId, data }) {
-        for (let socket of this.sockets)this.send(socket, JSON.stringify({
-            type,
-            data,
-            compilationId
-        }));
+    sockWrite(message, token) {
+        let messageStr = JSON.stringify(message);
+        if (token) {
+            let socket = this.sockets.get(token);
+            socket && this.send(socket, messageStr);
+        } else for (let socket of this.sockets.values())this.send(socket, messageStr);
     }
-    singleWrite(socket, { type, data, compilationId }) {
-        this.send(socket, JSON.stringify({
-            type,
-            data,
-            compilationId
-        }));
+    singleWrite(socket, message) {
+        this.send(socket, JSON.stringify(message));
     }
     async close() {
         for (let socket of (this.clearHeartbeatTimer(), this.wsServer.removeAllListeners(), this.wsServer.clients))socket.terminate();
-        for (let socket of this.sockets)socket.close();
-        return this.stats = {}, this.initialChunks = {}, this.sockets.length = 0, new Promise((resolve, reject)=>{
+        for (let socket of this.sockets.values())socket.close();
+        return this.stats = {}, this.initialChunks = {}, this.sockets.clear(), new Promise((resolve, reject)=>{
             this.wsServer.close((err)=>{
                 err ? reject(err) : resolve();
             });
         });
     }
-    onConnect(socket, params) {
+    onConnect(socket, token) {
         socket.isAlive = !0, socket.on('pong', ()=>{
             socket.isAlive = !0;
-        }), this.sockets.push(socket), socket.on('close', ()=>{
-            let index = this.sockets.indexOf(socket);
-            index >= 0 && this.sockets.splice(index, 1);
+        }), this.sockets.set(token, socket), socket.on('close', ()=>{
+            this.sockets.delete(token);
         }), (this.options.hmr || this.options.liveReload) && this.singleWrite(socket, {
-            type: 'hot',
-            compilationId: params.compilationId
+            type: 'hot'
         }), this.stats && this.sendStats({
             force: !0,
-            compilationId: params.compilationId
+            token
         });
     }
     getStats(name) {
@@ -4312,37 +4317,33 @@ class SocketServer {
             root: curStats.compilation.compiler.options.context
         } : null;
     }
-    sendStats({ force = !1, compilationId }) {
-        let result = this.getStats(compilationId);
+    sendStats({ force = !1, token }) {
+        let result = this.getStats(token);
         if (!result) return null;
         let { statsJson, root } = result, newInitialChunks = new Set();
         if (statsJson.entrypoints) for (let entrypoint of Object.values(statsJson.entrypoints)){
             let chunks = entrypoint.chunks;
             if (Array.isArray(chunks)) for (let chunkName of chunks)chunkName && newInitialChunks.add(String(chunkName));
         }
-        let initialChunks = this.initialChunks[compilationId], shouldReload = !!statsJson.entrypoints && !!initialChunks && !(initialChunks.size === newInitialChunks.size && [
+        let initialChunks = this.initialChunks[token], shouldReload = !!statsJson.entrypoints && !!initialChunks && !(initialChunks.size === newInitialChunks.size && [
             ...initialChunks
         ].every((value)=>newInitialChunks.has(value)));
-        if (this.initialChunks[compilationId] = newInitialChunks, shouldReload) return this.sockWrite({
-            type: 'static-changed',
-            compilationId
-        });
+        if (this.initialChunks[token] = newInitialChunks, shouldReload) return this.sockWrite({
+            type: 'static-changed'
+        }, token);
         if (!force && statsJson && !statsJson.errorsCount && statsJson.assets && statsJson.assets.every((asset)=>!asset.emitted)) return this.sockWrite({
-            type: 'ok',
-            compilationId
-        });
+            type: 'ok'
+        }, token);
         if (this.sockWrite({
             type: 'hash',
-            compilationId,
             data: statsJson.hash
-        }), statsJson.errorsCount) {
+        }, token), statsJson.errorsCount) {
             let { errors: formattedErrors } = formatStatsMessages({
                 errors: getAllStatsErrors(statsJson),
                 warnings: []
             });
             return this.sockWrite({
                 type: 'errors',
-                compilationId,
                 data: {
                     text: formattedErrors,
                     html: function(errors, root) {
@@ -4500,7 +4501,7 @@ class SocketServer {
 `;
                     }(formattedErrors, root)
                 }
-            });
+            }, token);
         }
         if (statsJson.warningsCount) {
             let { warnings: formattedWarnings } = formatStatsMessages({
@@ -4509,29 +4510,30 @@ class SocketServer {
             });
             return this.sockWrite({
                 type: 'warnings',
-                compilationId,
                 data: {
                     text: formattedWarnings
                 }
-            });
+            }, token);
         }
         return this.sockWrite({
-            type: 'ok',
-            compilationId
-        });
+            type: 'ok'
+        }, token);
     }
     send(connection, message) {
         1 === connection.readyState && connection.send(message);
     }
-    constructor(options){
-        socketServer_define_property(this, "wsServer", void 0), socketServer_define_property(this, "sockets", []), socketServer_define_property(this, "options", void 0), socketServer_define_property(this, "stats", void 0), socketServer_define_property(this, "initialChunks", void 0), socketServer_define_property(this, "heartbeatTimer", null), socketServer_define_property(this, "upgrade", (req, sock, head)=>{
-            this.wsServer.shouldHandle(req) && this.wsServer.handleUpgrade(req, sock, head, (connection)=>{
+    constructor(options, environments){
+        socketServer_define_property(this, "wsServer", void 0), socketServer_define_property(this, "sockets", new Map()), socketServer_define_property(this, "options", void 0), socketServer_define_property(this, "stats", void 0), socketServer_define_property(this, "initialChunks", void 0), socketServer_define_property(this, "heartbeatTimer", null), socketServer_define_property(this, "environments", void 0), socketServer_define_property(this, "upgrade", (req, socket, head)=>{
+            if (!this.wsServer.shouldHandle(req)) return;
+            let query = parseQueryString(req);
+            if (!Object.values(this.environments).map((env)=>env.webSocketToken).includes(query.token)) return void socket.destroy();
+            this.wsServer.handleUpgrade(req, socket, head, (connection)=>{
                 this.wsServer.emit('connection', connection, req);
             });
         }), socketServer_define_property(this, "checkSockets", ()=>{
             for (let socket of this.wsServer.clients)socket.isAlive ? (socket.isAlive = !1, socket.ping(()=>{})) : socket.terminate();
             null !== this.heartbeatTimer && (this.heartbeatTimer = setTimeout(this.checkSockets, 30000).unref());
-        }), this.options = options, this.stats = {}, this.initialChunks = {};
+        }), this.options = options, this.stats = {}, this.initialChunks = {}, this.environments = environments;
     }
 }
 function compilationManager_define_property(obj, key, value) {
@@ -4564,29 +4566,28 @@ class CompilationManager {
         });
     }
     async setupCompilationMiddleware() {
-        let { devConfig, serverConfig, publicPaths } = this, clientPaths = function(devConfig) {
+        let { devConfig, serverConfig, publicPaths, environments } = this, clientPaths = function(devConfig) {
             var _devConfig_client;
             let clientPaths = [];
             return (devConfig.hmr || devConfig.liveReload) && (clientPaths.push(compilationManager_require.resolve('@rsbuild/core/client/hmr')), (null == (_devConfig_client = devConfig.client) ? void 0 : _devConfig_client.overlay) && clientPaths.push(`${compilationManager_require.resolve('@rsbuild/core/client/overlay')}`)), clientPaths;
         }(devConfig), middleware = await getCompilationMiddleware(this.compiler, {
             callbacks: {
-                onInvalid: (compilationId, fileName)=>{
+                onInvalid: (token, fileName)=>{
                     if ('string' == typeof fileName && HTML_REGEX.test(fileName)) return void this.socketServer.sockWrite({
-                        type: 'static-changed',
-                        compilationId
-                    });
+                        type: 'static-changed'
+                    }, token);
                     this.socketServer.sockWrite({
-                        type: 'invalid',
-                        compilationId
-                    });
+                        type: 'invalid'
+                    }, token);
                 },
-                onDone: (stats)=>{
-                    this.socketServer.updateStats(stats);
+                onDone: (token, stats)=>{
+                    this.socketServer.updateStats(stats, token);
                 }
             },
             clientPaths,
             devConfig,
-            serverConfig
+            serverConfig,
+            environments
         }), { base } = serverConfig, assetPrefixes = publicPaths.map(getPathnameFromUrl).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)=>{
@@ -4596,7 +4597,7 @@ class CompilationManager {
         wrapper.close = middleware.close, wrapper.watch = middleware.watch, this.middleware = wrapper;
     }
     constructor({ dev, server, compiler, publicPaths, environments }){
-        compilationManager_define_property(this, "middleware", void 0), compilationManager_define_property(this, "outputFileSystem", void 0), compilationManager_define_property(this, "devConfig", void 0), compilationManager_define_property(this, "serverConfig", void 0), compilationManager_define_property(this, "compiler", void 0), compilationManager_define_property(this, "publicPaths", void 0), compilationManager_define_property(this, "socketServer", void 0), compilationManager_define_property(this, "readFileSync", (fileName)=>'readFileSync' in this.outputFileSystem ? this.outputFileSystem.readFileSync(fileName, 'utf-8') : node_fs.readFileSync(fileName, 'utf-8')), this.devConfig = ((config, environments)=>{
+        compilationManager_define_property(this, "middleware", void 0), compilationManager_define_property(this, "outputFileSystem", void 0), compilationManager_define_property(this, "devConfig", void 0), compilationManager_define_property(this, "serverConfig", void 0), compilationManager_define_property(this, "compiler", void 0), compilationManager_define_property(this, "environments", void 0), compilationManager_define_property(this, "publicPaths", void 0), compilationManager_define_property(this, "socketServer", void 0), compilationManager_define_property(this, "readFileSync", (fileName)=>'readFileSync' in this.outputFileSystem ? this.outputFileSystem.readFileSync(fileName, 'utf-8') : node_fs.readFileSync(fileName, 'utf-8')), this.devConfig = ((config, environments)=>{
             let writeToDiskValues = Object.values(environments).map((env)=>env.config.dev.writeToDisk);
             return 1 === new Set(writeToDiskValues).size ? {
                 ...config,
@@ -4608,11 +4609,13 @@ class CompilationManager {
                     return compilationName && environments[compilationName] && (writeToDisk = environments[compilationName].config.dev.writeToDisk ?? writeToDisk), 'function' == typeof writeToDisk ? writeToDisk(filePath) : writeToDisk;
                 }
             };
-        })(dev, environments), this.serverConfig = server, this.compiler = compiler, this.publicPaths = publicPaths, this.outputFileSystem = node_fs, this.socketServer = new SocketServer(dev);
+        })(dev, environments), this.serverConfig = server, this.compiler = compiler, this.environments = environments, this.publicPaths = publicPaths, this.outputFileSystem = node_fs, this.socketServer = new SocketServer(dev, environments);
     }
 }
-let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i, gzipMiddleware = ({ level = node_zlib.constants.Z_BEST_SPEED } = {})=>(req, res, next)=>{
-        let gzip, writeHeadStatus, accept = req.headers['accept-encoding'], encoding = 'string' == typeof accept && ENCODING_REGEX.test(accept);
+let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i, gzipMiddleware = ({ filter, level = node_zlib.constants.Z_BEST_SPEED } = {})=>(req, res, next)=>{
+        let gzip, writeHeadStatus;
+        if (filter && !1 === filter(req, res)) return void next();
+        let accept = req.headers['accept-encoding'], encoding = 'string' == typeof accept && ENCODING_REGEX.test(accept);
         if ('HEAD' === req.method || !encoding) return void next();
         let started = !1, { end, write, on, writeHead } = res, listeners = [], start = ()=>{
             if (!started) {
@@ -4736,7 +4739,8 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
         let { middlewares: proxyMiddlewares, upgrade } = await createProxyMiddleware(server.proxy);
         for (let middleware of (upgradeEvents.push(upgrade), proxyMiddlewares))middlewares.push(middleware);
     }
-    if (server.compress && middlewares.push(gzipMiddleware()), 'dev' === context.action && 'rspack' === context.bundlerType && compilationManager) {
+    let { compress } = server;
+    if (compress && middlewares.push(gzipMiddleware('object' == typeof compress ? compress : void 0)), 'dev' === context.action && 'rspack' === context.bundlerType && compilationManager) {
         var _compiler_options_experiments;
         let { compiler } = compilationManager;
         (helpers_isMultiCompiler(compiler) ? compiler.compilers.some((childCompiler)=>{
@@ -5154,7 +5158,7 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunne
 }, shutdownRefCount = 0, setupGracefulShutdown = ()=>{
     shutdownRefCount++;
     let onSigterm = ()=>{
-        handleTermination(constants.signals.SIGTERM + 128);
+        handleTermination(external_node_os_constants.signals.SIGTERM + 128);
     };
     process.once('SIGTERM', onSigterm);
     let isCI = 'true' === process.env.CI, onStdinEnd = ()=>{
@@ -5487,9 +5491,14 @@ class RsbuildProdServer {
             for (let middleware of middlewares)this.middlewares.use(middleware);
             this.app.on('upgrade', upgrade);
         }
-        if (compress && this.middlewares.use(gzipMiddleware({
-            level: 6
-        })), base && '/' !== base && this.middlewares.use(getBaseMiddleware({
+        if (compress) {
+            let { constants } = await import("node:zlib");
+            this.middlewares.use(gzipMiddleware({
+                level: constants.Z_DEFAULT_COMPRESSION,
+                ...'object' == typeof compress ? compress : void 0
+            }));
+        }
+        if (base && '/' !== base && this.middlewares.use(getBaseMiddleware({
             base
         })), await this.applyStaticAssetMiddleware(), historyApiFallback) {
             let { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js"), historyApiFallbackMiddleware = connectHistoryApiFallback(!0 === historyApiFallback ? {} : historyApiFallback);
@@ -6275,8 +6284,11 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         rule.test(CSS_REGEX).type("javascript/auto").dependency({
                             not: 'url'
                         }).resourceQuery({
-                            not: /raw|inline/
-                        }), inlineRule.test(CSS_REGEX).type("javascript/auto").resourceQuery(/inline/), chain.module.rule(CHAIN_ID.RULE.CSS_RAW).test(CSS_REGEX).type('asset/source').resourceQuery(/raw/);
+                            not: [
+                                RAW_QUERY_REGEX,
+                                INLINE_QUERY_REGEX
+                            ]
+                        }), inlineRule.test(CSS_REGEX).type("javascript/auto").resourceQuery(INLINE_QUERY_REGEX), chain.module.rule(CHAIN_ID.RULE.CSS_RAW).test(CSS_REGEX).type('asset/source').resourceQuery(RAW_QUERY_REGEX);
                         let emitCss = config.output.emitCss ?? 'web' === target;
                         if (emitCss) if (config.output.injectStyles) {
                             let styleLoaderOptions = reduceConfigs({
@@ -6458,9 +6470,9 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         let { config, browserslist } = environment, cacheRoot = node_path.join(api.context.cachePath, '.swc'), rule = chain.module.rule(CHAIN_ID.RULE.JS).test(SCRIPT_REGEX).type("javascript/auto").dependency({
                             not: 'url'
                         }).resourceQuery({
-                            not: /raw/
+                            not: RAW_QUERY_REGEX
                         });
-                        chain.module.rule(CHAIN_ID.RULE.JS_RAW).test(SCRIPT_REGEX).type('asset/source').resourceQuery(/raw/);
+                        chain.module.rule(CHAIN_ID.RULE.JS_RAW).test(SCRIPT_REGEX).type('asset/source').resourceQuery(RAW_QUERY_REGEX);
                         let dataUriRule = chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
                             or: [
                                 "text/javascript",
@@ -7253,9 +7265,9 @@ async function createRsbuild(options = {}) {
                         exitCode
                     });
                 }, exitHook_callbacks.add(onExit), isRegistered || (isRegistered = !0, node_process.on('SIGINT', ()=>{
-                    exit(constants.signals.SIGINT + 128, 'SIGINT');
+                    exit(external_node_os_constants.signals.SIGINT + 128, 'SIGINT');
                 }), node_process.once('SIGTERM', ()=>{
-                    exit(constants.signals.SIGTERM + 128, 'SIGTERM');
+                    exit(external_node_os_constants.signals.SIGTERM + 128, 'SIGTERM');
                 }), node_process.once('exit', (exitCode)=>{
                     exit(exitCode, 'exit');
                 })), onExitListened = !0;
@@ -7633,11 +7645,11 @@ async function runCLI() {
         ].includes(level) && (logger.level = level);
     }
     let { npm_execpath } = process.env;
-    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.2\n`);
+    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.4\n`);
     try {
         !function() {
             let cli = ((name = "")=>new CAC(name))('rsbuild');
-            cli.help(), cli.version("1.4.2"), 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`', {
+            cli.help(), cli.version("1.4.4"), 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('--log-level <level>', 'specify the log level, can be `info`, `warn`, `error` or `silent`').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: [
@@ -7695,5 +7707,5 @@ async function runCLI() {
         logger.error('Failed to start Rsbuild CLI.'), logger.error(err);
     }
 }
-let src_version = "1.4.2";
+let src_version = "1.4.4";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger, mergeRsbuildConfig, rspack, runCLI, src_version as version };

package/dist-types/constants.d.ts

@@ -28,6 +28,8 @@ export declare const HTML_REGEX: RegExp;
 export declare const JS_REGEX: RegExp;
 export declare const SCRIPT_REGEX: RegExp;
 export declare const CSS_REGEX: RegExp;
+export declare const RAW_QUERY_REGEX: RegExp;
+export declare const INLINE_QUERY_REGEX: RegExp;
 export declare const NODE_MODULES_REGEX: RegExp;
 export declare const PLUGIN_SWC_NAME = "rsbuild:swc";
 export declare const PLUGIN_CSS_NAME = "rsbuild:css";

package/dist-types/index.d.ts

@@ -19,4 +19,4 @@ export { type Logger, logger } from './logger';
 export { mergeRsbuildConfig } from './mergeConfig';
 export type { RsbuildDevServer } from './server/devServer';
 export type { StartServerResult } from './server/helper';
-export type { AliasStrategy, AppIcon, AppIconItem, Build, BuildOptions, BundlerPluginInstance, Charset, CleanDistPath, CleanDistPathObject, ClientConfig, CliShortcut, ConfigChain, ConfigChainWithContext, ConsoleType, CreateCompiler, CreateRsbuildOptions, CrossOrigin, CSSLoaderOptions, CSSModules, CSSModulesLocalsConvention, DataUriLimit, Decorators, DevConfig, DistPathConfig, EnvironmentConfig, EnvironmentContext, FilenameConfig, HistoryApiFallbackContext, HistoryApiFallbackOptions, HtmlBasicTag, HtmlConfig, HtmlFallback, HtmlRspackPlugin, HtmlTagContext, HtmlTagDescriptor, HtmlTagHandler, InlineChunkConfig, InlineChunkTest, InlineChunkTestFunction, InspectConfigOptions, InspectConfigResult, InternalContext, LegalComments, LogLevel, ManifestConfig, ManifestData, ManifestObjectConfig, MergedEnvironmentConfig, MetaAttrs, MetaOptions, Minify, ModifyBundlerChainFn, ModifyBundlerChainUtils, ModifyChainUtils, ModifyEnvironmentConfigFn, ModifyEnvironmentConfigUtils, ModifyHTMLContext, ModifyHTMLFn, ModifyHTMLTagsContext, ModifyHTMLTagsFn, ModifyRsbuildConfigFn, ModifyRsbuildConfigUtils, ModifyRspackConfigFn, ModifyRspackConfigUtils, ModifyWebpackChainFn, ModifyWebpackChainUtils, ModifyWebpackConfigFn, ModifyWebpackConfigUtils, ModuleFederationConfig, NormalizedConfig, NormalizedDevConfig, NormalizedEnvironmentConfig, NormalizedHtmlConfig, NormalizedModuleFederationConfig, NormalizedOutputConfig, NormalizedPerformanceConfig, NormalizedSecurityConfig, NormalizedServerConfig, NormalizedSourceConfig, NormalizedToolsConfig, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterEnvironmentCompileFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnBeforeEnvironmentCompileFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnCloseBuildFn, OnCloseDevServerFn, OnDevCompileDoneFn, OnExitFn, OutputConfig, OutputStructure, PerformanceConfig, PluginManager, Polyfill, PostCSSLoaderOptions, PostCSSOptions, PostCSSPlugin, PreconnectOption, PreviewOptions, PrintUrls, ProcessAssetsDescriptor, ProcessAssetsHandler, ProcessAssetsHook, ProgressBarConfig, ProxyBypass, ProxyConfig, ProxyFilter, ProxyOptions, PublicDir, PublicDirOptions, RequestHandler, ResolvedCreateRsbuildOptions, ResolveHandler, ResolveHook, ResourceHintsIncludeType, RsbuildConfig, RsbuildContext, RsbuildEntry, RsbuildEntryDescription, RsbuildInstance, RsbuildMode, RsbuildPlugin, RsbuildPluginAPI, RsbuildPlugins, RsbuildProvider, RsbuildProviderHelpers, RsbuildTarget, RspackChain, RspackRule, ScriptInject, ScriptLoading, SecurityConfig, ServerConfig, SetupMiddlewaresContext, SetupMiddlewaresFn, SourceConfig, SourceMap, SplitChunks, SriAlgorithm, SriOptions, StartDevServerOptions, StyleLoaderOptions, ToolsConfig, TransformContext, TransformDescriptor, TransformHandler, TransformHook, TransformImport, WatchFiles, } from './types';
+export type { AliasStrategy, AppIcon, AppIconItem, Build, BuildOptions, BundlerPluginInstance, Charset, CleanDistPath, CleanDistPathObject, ClientConfig, CliShortcut, CompressOptions, ConfigChain, ConfigChainWithContext, ConsoleType, CreateCompiler, CreateRsbuildOptions, CrossOrigin, CSSLoaderOptions, CSSModules, CSSModulesLocalsConvention, DataUriLimit, Decorators, DevConfig, DistPathConfig, EnvironmentConfig, EnvironmentContext, FilenameConfig, HistoryApiFallbackContext, HistoryApiFallbackOptions, HtmlBasicTag, HtmlConfig, HtmlFallback, HtmlRspackPlugin, HtmlTagContext, HtmlTagDescriptor, HtmlTagHandler, InlineChunkConfig, InlineChunkTest, InlineChunkTestFunction, InspectConfigOptions, InspectConfigResult, InternalContext, LegalComments, LogLevel, ManifestConfig, ManifestData, ManifestObjectConfig, MergedEnvironmentConfig, MetaAttrs, MetaOptions, Minify, ModifyBundlerChainFn, ModifyBundlerChainUtils, ModifyChainUtils, ModifyEnvironmentConfigFn, ModifyEnvironmentConfigUtils, ModifyHTMLContext, ModifyHTMLFn, ModifyHTMLTagsContext, ModifyHTMLTagsFn, ModifyRsbuildConfigFn, ModifyRsbuildConfigUtils, ModifyRspackConfigFn, ModifyRspackConfigUtils, ModifyWebpackChainFn, ModifyWebpackChainUtils, ModifyWebpackConfigFn, ModifyWebpackConfigUtils, ModuleFederationConfig, NormalizedConfig, NormalizedDevConfig, NormalizedEnvironmentConfig, NormalizedHtmlConfig, NormalizedModuleFederationConfig, NormalizedOutputConfig, NormalizedPerformanceConfig, NormalizedSecurityConfig, NormalizedServerConfig, NormalizedSourceConfig, NormalizedToolsConfig, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterEnvironmentCompileFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnBeforeEnvironmentCompileFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnCloseBuildFn, OnCloseDevServerFn, OnDevCompileDoneFn, OnExitFn, OutputConfig, OutputStructure, PerformanceConfig, PluginManager, Polyfill, PostCSSLoaderOptions, PostCSSOptions, PostCSSPlugin, PreconnectOption, PreviewOptions, PrintUrls, ProcessAssetsDescriptor, ProcessAssetsHandler, ProcessAssetsHook, ProgressBarConfig, ProxyBypass, ProxyConfig, ProxyFilter, ProxyOptions, PublicDir, PublicDirOptions, RequestHandler, ResolvedCreateRsbuildOptions, ResolveHandler, ResolveHook, ResourceHintsIncludeType, RsbuildConfig, RsbuildContext, RsbuildEntry, RsbuildEntryDescription, RsbuildInstance, RsbuildMode, RsbuildPlugin, RsbuildPluginAPI, RsbuildPlugins, RsbuildProvider, RsbuildProviderHelpers, RsbuildTarget, RspackChain, RspackRule, ScriptInject, ScriptLoading, SecurityConfig, ServerConfig, SetupMiddlewaresContext, SetupMiddlewaresFn, SourceConfig, SourceMap, SplitChunks, SriAlgorithm, SriOptions, StartDevServerOptions, StyleLoaderOptions, ToolsConfig, TransformContext, TransformDescriptor, TransformHandler, TransformHook, TransformImport, WatchFiles, } from './types';

package/dist-types/server/compilationManager.d.ts

@@ -1,11 +1,11 @@
-import type { EnvironmentContext, DevConfig as OriginDevConfig, Rspack, ServerConfig } from '../types';
+import type { EnvironmentContext, NormalizedDevConfig, NormalizedServerConfig, Rspack } from '../types';
 import { type CompilationMiddleware } from './compilationMiddleware';
 import { SocketServer } from './socketServer';
 type Options = {
     publicPaths: string[];
     environments: Record<string, EnvironmentContext>;
-    dev: OriginDevConfig;
-    server: ServerConfig;
+    dev: NormalizedDevConfig;
+    server: NormalizedServerConfig;
     compiler: Rspack.Compiler | Rspack.MultiCompiler;
 };
 /**
@@ -19,6 +19,7 @@ export declare class CompilationManager {
     private devConfig;
     private serverConfig;
     compiler: Rspack.Compiler | Rspack.MultiCompiler;
+    private environments;
     private publicPaths;
     socketServer: SocketServer;
     constructor({ dev, server, compiler, publicPaths, environments }: Options);

package/dist-types/server/compilationMiddleware.d.ts

@@ -1,16 +1,20 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Compiler, MultiCompiler } from '@rspack/core';
-import type { DevConfig, NextFunction, ServerConfig } from '../types';
+import type { Compiler, MultiCompiler, Stats } from '@rspack/core';
+import type { DevConfig, EnvironmentContext, NextFunction, ServerConfig } from '../types';
 export declare const isClientCompiler: (compiler: {
     options: {
         target?: Compiler["options"]["target"];
     };
 }) => boolean;
-type ServerCallbacks = {
-    onInvalid: (compilationId?: string, fileName?: string | null) => void;
-    onDone: (stats: any) => void;
+export type ServerCallbacks = {
+    onInvalid: (token: string, fileName?: string | null) => void;
+    onDone: (token: string, stats: Stats) => void;
 };
-export declare const setupServerHooks: (compiler: Compiler, { onDone, onInvalid }: ServerCallbacks) => void;
+export declare const setupServerHooks: ({ compiler, token, callbacks: { onDone, onInvalid }, }: {
+    compiler: Compiler;
+    token: string;
+    callbacks: ServerCallbacks;
+}) => void;
 type Middleware = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>;
 export type CompilationMiddlewareOptions = {
     /**
@@ -23,6 +27,7 @@ export type CompilationMiddlewareOptions = {
     callbacks: ServerCallbacks;
     devConfig: DevConfig;
     serverConfig: ServerConfig;
+    environments: Record<string, EnvironmentContext>;
 };
 export type CompilationMiddleware = Middleware & {
     close: (callback: (err: Error | null | undefined) => void) => any;

package/dist-types/server/gzipMiddleware.d.ts

@@ -1,4 +1,2 @@
-import type { RequestHandler } from '../types';
-export declare const gzipMiddleware: ({ level, }?: {
-    level?: number;
-}) => RequestHandler;
+import type { CompressOptions, RequestHandler } from '../types';
+export declare const gzipMiddleware: ({ filter, level, }?: CompressOptions) => RequestHandler;

package/dist-types/server/helper.d.ts

@@ -1,7 +1,7 @@
 import type { IncomingMessage, Server } from 'node:http';
 import type { Http2SecureServer } from 'node:http2';
 import type { Socket } from 'node:net';
-import type { InternalContext, NormalizedConfig, OutputStructure, PrintUrls, Routes, RsbuildEntry, Rspack } from '../types';
+import type { InternalContext, NormalizedConfig, OutputStructure, PrintUrls, Routes, RsbuildEntry } from '../types';
 /**
  * It used to subscribe http upgrade event
  */
@@ -71,7 +71,6 @@ export declare const getAddressUrls: ({ protocol, port, host, }: {
     port: number;
     host?: string;
 }) => Promise<AddressUrl[]>;
-export declare const getCompilationId: (compiler: Rspack.Compiler | Rspack.Compilation) => string;
 export declare function getServerTerminator(server: Server | Http2SecureServer): () => Promise<void>;
 /**
  * Escape HTML characters

package/dist-types/server/socketServer.d.ts

@@ -1,10 +1,9 @@
 import type { IncomingMessage } from 'node:http';
 import type { Socket } from 'node:net';
-import type { DevConfig, Rspack } from '../types';
+import type { DevConfig, EnvironmentContext, Rspack } from '../types';
 import type { SockWriteType } from './devServer';
 interface SocketMessage {
     type: SockWriteType;
-    compilationId?: string;
     data?: Record<string, any> | string | boolean;
 }
 export declare class SocketServer {
@@ -14,13 +13,20 @@ export declare class SocketServer {
     private stats;
     private initialChunks;
     private heartbeatTimer;
-    constructor(options: DevConfig);
-    upgrade: (req: IncomingMessage, sock: Socket, head: any) => void;
+    private environments;
+    constructor(options: DevConfig, environments: Record<string, EnvironmentContext>);
+    upgrade: (req: IncomingMessage, socket: Socket, head: Buffer) => void;
     private checkSockets;
     private clearHeartbeatTimer;
     prepare(): Promise<void>;
-    updateStats(stats: Rspack.Stats): void;
-    sockWrite({ type, compilationId, data }: SocketMessage): void;
+    updateStats(stats: Rspack.Stats, token: string): void;
+    /**
+     * Write message to each socket
+     * @param message - The message to send
+     * @param token - The token of the socket to send the message to,
+     * if not provided, the message will be sent to all sockets
+     */
+    sockWrite(message: SocketMessage, token?: string): void;
     private singleWrite;
     close(): Promise<void>;
     private onConnect;