@rsbuild/core 2.1.5 → 2.1.7

package/dist/711.js

@@ -1,13 +1,12 @@
 /*! LICENSE: 711.js.LICENSE.txt */
-let flagForceColor, runtimeProcessArgs, runtimeInfo, swcHelpersPath, pluginHelper_htmlPlugin;
+let runtimeProcessArgs, runtimeInfo, swcHelpersPath, pluginHelper_htmlPlugin;
 import { rspack as core_rspack } from "@rspack/core";
 import node_util, { stripVTControlCharacters } from "node:util";
-import node_process from "node:process";
-import node_os, { constants as external_node_os_constants } from "node:os";
-import node_tty from "node:tty";
 import node_path, { dirname as external_node_path_dirname, isAbsolute as external_node_path_isAbsolute, join, posix, relative, resolve as external_node_path_resolve, sep, win32 } from "node:path";
 import { builtinModules, createRequire, createRequire as __rspack_createRequire } from "node:module";
 import node_fs, { existsSync } from "node:fs";
+import node_os, { constants as external_node_os_constants } from "node:os";
+import node_process from "node:process";
 import { URL as external_node_url_URL, pathToFileURL, fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { isPromise, isRegExp } from "node:util/types";
 import { readFile } from "node:fs/promises";
@@ -387,8 +386,8 @@ __webpack_require__.add({
             return (asyncHooks.AsyncResource && (res = new asyncHooks.AsyncResource(fn.name || 'bound-anonymous-fn')), res && res.runInAsyncScope) ? res.runInAsyncScope.bind(res, fn, null) : fn;
         }
     },
-    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/index.js" (module, __unused_rspack_exports, __webpack_require__) {
-        let yaml, { resolve } = __webpack_require__("node:path?435f"), config = __webpack_require__("../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js"), loadOptions = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/options.js"), loadPlugins = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/plugins.js"), req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/req.js");
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let yaml, { resolve } = __webpack_require__("node:path?435f"), config = __webpack_require__("../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js"), loadOptions = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/options.js"), loadPlugins = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/plugins.js"), req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/req.js");
         async function processResult(ctx, result) {
             let obj, file = result.filepath || '', projectConfig = ((obj = result.config) && obj.__esModule ? obj : {
                 default: obj
@@ -461,8 +460,8 @@ __webpack_require__.add({
             });
         };
     },
-    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/options.js" (module, __unused_rspack_exports, __webpack_require__) {
-        let req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/req.js");
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/options.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/req.js");
         module.exports = async function options(config, file) {
             if (config.parser && 'string' == typeof config.parser) try {
                 config.parser = await req(config.parser, file);
@@ -482,8 +481,8 @@ __webpack_require__.add({
             return config;
         };
     },
-    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/plugins.js" (module, __unused_rspack_exports, __webpack_require__) {
-        let req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/req.js");
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/plugins.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/req.js");
         async function load(plugin, options, file) {
             try {
                 if (null == options || 0 === Object.keys(options).length) return await req(plugin, file);
@@ -499,7 +498,7 @@ __webpack_require__.add({
             }), list;
         };
     },
-    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/req.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/req.js" (module, __unused_rspack_exports, __webpack_require__) {
         let tsx, jiti, { createRequire } = __webpack_require__("node:module?1bcb"), { pathToFileURL } = __webpack_require__("node:url?b4ec"), TS_EXT_RE = /\.[mc]?ts$/, importError = [];
         module.exports = async function req(name, rootFile = __rspack_import_meta_filename__) {
             let url = createRequire(rootFile).resolve(name);
@@ -625,134 +624,35 @@ let createStyler = (style)=>(text)=>node_util.styleText(style, String(text)), co
     magenta: createStyler('magenta'),
     underline: createStyler('underline'),
     strikethrough: createStyler('strikethrough')
-};
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : node_process.argv) {
-    let prefix = flag.startsWith('-') ? '' : 1 === flag.length ? '-' : '--', position = argv.indexOf(prefix + flag), terminatorPosition = argv.indexOf('--');
-    return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
-}
-let { env: dist_env } = node_process;
-function envForceColor() {
-    if (!('FORCE_COLOR' in dist_env)) return;
-    if ('true' === dist_env.FORCE_COLOR) return 1;
-    if ('false' === dist_env.FORCE_COLOR) return 0;
-    if (0 === dist_env.FORCE_COLOR.length) return 1;
-    let level = Math.min(Number.parseInt(dist_env.FORCE_COLOR, 10), 3);
-    if ([
-        0,
-        1,
-        2,
-        3
-    ].includes(level)) return level;
-}
-function translateLevel(level) {
-    return 0 !== level && {
-        level,
-        hasBasic: !0,
-        has256: level >= 2,
-        has16m: level >= 3
-    };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = !0 } = {}) {
-    let noFlagForceColor = envForceColor();
-    void 0 !== noFlagForceColor && (flagForceColor = noFlagForceColor);
-    let forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-    if (0 === forceColor) return 0;
-    if (sniffFlags) {
-        if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) return 3;
-        if (hasFlag('color=256')) return 2;
-    }
-    if ('TF_BUILD' in dist_env && 'AGENT_NAME' in dist_env) return 1;
-    if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
-    let min = forceColor || 0;
-    if ('dumb' === dist_env.TERM) return min;
-    if ('win32' === node_process.platform) {
-        let osRelease = node_os.release().split('.');
-        return Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586 ? Number(osRelease[2]) >= 14931 ? 3 : 2 : 1;
-    }
-    if ('CI' in dist_env) return [
-        'GITHUB_ACTIONS',
-        'GITEA_ACTIONS',
-        'CIRCLECI'
-    ].some((key)=>key in dist_env) ? 3 : [
-        'TRAVIS',
-        'APPVEYOR',
-        'GITLAB_CI',
-        'BUILDKITE',
-        'DRONE'
-    ].some((sign)=>sign in dist_env) || 'codeship' === dist_env.CI_NAME ? 1 : min;
-    if ('TEAMCITY_VERSION' in dist_env) return +!!/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(dist_env.TEAMCITY_VERSION);
-    if ('truecolor' === dist_env.COLORTERM || 'xterm-kitty' === dist_env.TERM || 'xterm-ghostty' === dist_env.TERM || 'wezterm' === dist_env.TERM) return 3;
-    if ('TERM_PROGRAM' in dist_env) {
-        let version = Number.parseInt((dist_env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
-        switch(dist_env.TERM_PROGRAM){
-            case 'iTerm.app':
-                return version >= 3 ? 3 : 2;
-            case 'Apple_Terminal':
-                return 2;
-        }
-    }
-    return /-256(color)?$/i.test(dist_env.TERM) ? 2 : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(dist_env.TERM) || 'COLORTERM' in dist_env ? 1 : min;
-}
-function createSupportsColor(stream, options = {}) {
-    return translateLevel(_supportsColor(stream, {
-        streamIsTTY: stream && stream.isTTY,
-        ...options
-    }));
-}
-hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never') ? flagForceColor = 0 : (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) && (flagForceColor = 1);
-let supportsColor = {
-    stdout: createSupportsColor({
-        isTTY: node_tty.isatty(1)
-    }),
-    stderr: createSupportsColor({
-        isTTY: node_tty.isatty(2)
-    })
-}, colorLevel = supportsColor.stdout ? supportsColor.stdout.level : 0, errorStackRegExp = /at [^\r\n]{0,200}:\d+:\d+[\s\)]*$/, anonymousErrorStackRegExp = /at [^\r\n]{0,200}\(<anonymous>\)$/, indexErrorStackRegExp = /at [^\r\n]{0,200}\(index\s\d+\)$/, isWord = (char)=>!/[\s\n]/.test(char), LOG_LEVEL = {
+}, supportsTrueColor = !0 === process.stdout.isTTY && process.stdout.hasColors(16777216, process.env), LOG_LEVEL = {
     silent: -1,
     error: 0,
     warn: 1,
     info: 2,
     log: 2,
     verbose: 3
+}, createLogType = (label, level, style)=>{
+    let formattedLabel;
+    return {
+        get label () {
+            return formattedLabel ??= color.bold(style(label.padEnd(7)));
+        },
+        level
+    };
 }, LOG_TYPES = {
-    error: {
-        label: 'error',
-        level: 'error',
-        color: color.red
-    },
-    warn: {
-        label: 'warn',
-        level: 'warn',
-        color: color.yellow
-    },
-    info: {
-        label: 'info',
-        level: 'info',
-        color: color.cyan
-    },
-    start: {
-        label: 'start',
-        level: 'info',
-        color: color.cyan
-    },
-    ready: {
-        label: 'ready',
-        level: 'info',
-        color: color.green
-    },
-    success: {
-        label: 'success',
-        level: 'info',
-        color: color.green
-    },
+    error: createLogType('error', 'error', color.red),
+    warn: createLogType('warn', 'warn', color.yellow),
+    info: createLogType('info', 'info', color.cyan),
+    start: createLogType('start', 'info', color.cyan),
+    ready: createLogType('ready', 'info', color.green),
+    success: createLogType('success', 'info', color.green),
     log: {
         level: 'info'
     },
-    debug: {
-        label: 'debug',
-        level: 'verbose',
-        color: color.magenta
-    }
+    debug: createLogType('debug', 'verbose', color.magenta)
+}, ANSI_REGEXP = RegExp("\x1b\\[[0-9;]*m", 'g'), errorStackRegExp = /at [^\r\n]{0,200}(?::\d+:\d+[\s)]*|\(<anonymous>\)|\(index\s\d+\))$/, isErrorStackMessage = (message)=>{
+    let stripped = message.replace(ANSI_REGEXP, '');
+    return errorStackRegExp.test(stripped);
 }, normalizeErrorMessage = (err)=>{
     if (err.stack) {
         let [rawName, ...rest] = err.stack.split('\n'), name = rawName.startsWith('Error: ') ? rawName.slice(7) : rawName;
@@ -760,26 +660,23 @@ let supportsColor = {
     }
     return err.message;
 }, createLogger = (options = {})=>{
-    let { level = 'info', prefix, console: console1 = globalThis.console } = options, maxLevel = level, log = (type, message, ...args)=>{
+    let { level = 'info', prefix, console: console1 = globalThis.console, alignMultiline } = options, maxLevel = level, log = (type, message, ...args)=>{
         let logType = LOG_TYPES[type], { level } = logType;
         if (LOG_LEVEL[level] > LOG_LEVEL[maxLevel]) return;
         if (null == message) return console1.log();
-        let label = '', text = '';
-        if ('label' in logType && (label = (logType.label || '').padEnd(7), label = color.bold(logType.color ? logType.color(label) : label)), message instanceof Error) {
+        let label = 'label' in logType ? logType.label : '', header = label ? prefix ? `${label} ${prefix}` : label : prefix, text = '', isErrorObject = message instanceof Error;
+        if (isErrorObject) {
             text += normalizeErrorMessage(message);
             let { cause } = message;
             cause && (text += color.yellow('\n  [cause]: '), text += cause instanceof Error ? normalizeErrorMessage(cause) : String(cause));
-        } else text = 'error' === level && 'string' == typeof message ? message.split('\n').map((line)=>errorStackRegExp.test(line) || anonymousErrorStackRegExp.test(line) || indexErrorStackRegExp.test(line) ? color.gray(line) : line).join('\n') : `${message}`;
-        prefix && (text = `${prefix} ${text}`), console1['error' === level || 'warn' === level ? level : 'log'](label.length ? `${label} ${text}` : text, ...args);
+        } else text = 'error' === level && 'string' == typeof message ? message.split('\n').map((line)=>isErrorStackMessage(line) ? color.gray(line) : line).join('\n') : `${message}`;
+        if (alignMultiline && header && !isErrorObject && text.includes('\n')) {
+            let indent = ' '.repeat(header.replace(ANSI_REGEXP, '').length + 1), skipStack = 'error' === level;
+            text = text.split('\n').map((line, i)=>0 === i || '' === line || skipStack && isErrorStackMessage(line) ? line : indent + line).join('\n');
+        }
+        console1['error' === level || 'warn' === level ? level : 'log'](header ? `${header} ${text}` : text, ...args);
     }, logger = {
-        greet: (message)=>log('log', ((message)=>{
-                if (colorLevel < 3) return 2 === colorLevel ? color.cyan(message) : message;
-                let chars = [
-                    ...message
-                ], steps = chars.filter(isWord).length, r = 189, g = 255, b = 243, rStep = -115 / steps, gStep = -61 / steps, bStep = -89 / steps, output = '';
-                for (let char of chars)isWord(char) && (r += rStep, g += gStep, b += bStep), output += `\x1b[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1b[39m`;
-                return color.bold(output);
-            })(message))
+        greet: (message)=>log('log', supportsTrueColor ? `\x1b[1;38;2;132;225;199m${message}\x1b[39;22m` : color.bold(color.cyan(message)))
     };
     return Object.keys(LOG_TYPES).forEach((key)=>{
         logger[key] = (...args)=>log(key, ...args);
@@ -2611,6 +2508,7 @@ function createAsyncHook() {
 function initHooks() {
     return {
         onExit: createAsyncHook(),
+        onRestart: createAsyncHook(),
         onCloseBuild: createAsyncHook(),
         onAfterBuild: createAsyncHook(),
         onBeforeBuild: createAsyncHook(),
@@ -3379,6 +3277,7 @@ function initPluginAPI({ context, pluginManager }) {
             getNormalizedConfig,
             isPluginExists: pluginManager.isPluginExists,
             onExit,
+            onRestart: hooks.onRestart.tap,
             onAfterBuild: hooks.onAfterBuild.tap,
             onCloseBuild: hooks.onCloseBuild.tap,
             onBeforeBuild: hooks.onBeforeBuild.tap,
@@ -3493,6 +3392,8 @@ function createPublicContext(context) {
         'action',
         'version',
         'rootPath',
+        'configFile',
+        'configFileDependencies',
         'distPath',
         'devServer',
         'cachePath',
@@ -3506,11 +3407,13 @@ function createPublicContext(context) {
         set: (target, prop)=>(target.logger.error(`Context is readonly, you can not assign to the "context.${prop}" prop.`), !0)
     });
 }
-async function createContext(options, userConfig, logger) {
-    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;
+async function createContext(options, userConfig, logger, loadConfigResult) {
+    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, hooks = initHooks();
     return {
-        version: "2.1.5",
+        version: "2.1.7",
         rootPath,
+        configFile: loadConfigResult?.filePath ?? userConfig._privateMeta?.configFilePath,
+        configFileDependencies: loadConfigResult?.dependencies ?? userConfig._privateMeta?.configFileDependencies ?? [],
         distPath: '',
         cachePath,
         logger,
@@ -3519,7 +3422,38 @@ async function createContext(options, userConfig, logger) {
         environments: {},
         environmentList: [],
         publicPathnames: [],
-        hooks: initHooks(),
+        hooks,
+        restartManager: (({ onRestart, restart })=>{
+            let cleanups = new Set();
+            return {
+                canRestart: !!restart,
+                registerCleanup: (cleanup)=>(cleanups.add(cleanup), ()=>{
+                        cleanups.delete(cleanup);
+                    }),
+                async requestRestart (context) {
+                    let firstError;
+                    if (!restart) return await onRestart(context), !1;
+                    let currentCleanups = cleanups;
+                    cleanups = new Set();
+                    let hasError = !1;
+                    try {
+                        await onRestart(context);
+                    } catch (error) {
+                        hasError = !0, firstError = error;
+                    }
+                    for (let cleanup of currentCleanups)try {
+                        await cleanup();
+                    } catch (error) {
+                        hasError || (hasError = !0, firstError = error);
+                    }
+                    if (hasError) throw firstError;
+                    return restart(context);
+                }
+            };
+        })({
+            onRestart: hooks.onRestart.callBatch,
+            restart: options.restart
+        }),
         config: {
             ...rsbuildConfig
         },
@@ -4036,7 +3970,7 @@ async function initRsbuildConfig({ context, pluginManager }) {
     }
     return tsconfigPaths.size && 'prefer-tsconfig' === normalizedBaseConfig.resolve.aliasStrategy && normalizedBaseConfig.dev.watchFiles.push({
         paths: Array.from(tsconfigPaths),
-        type: 'reload-server'
+        type: 'restart'
     }), context.normalizedConfig = {
         ...normalizedBaseConfig,
         environments
@@ -4253,8 +4187,132 @@ async function createCompiler_createCompiler(options) {
         rspackConfigs
     };
 }
+async function setupWatchFiles(options) {
+    let { config, root, buildManager } = options, { hmr, liveReload } = config.dev;
+    if (!hmr && !liveReload || !buildManager) return;
+    let closeDevFilesWatcher = await watchDevFiles(config.dev, buildManager, root), serverFilesWatcher = await watchServerFiles(config.server, buildManager, root);
+    return {
+        async close () {
+            await Promise.all([
+                closeDevFilesWatcher?.(),
+                serverFilesWatcher?.close()
+            ]);
+        }
+    };
+}
+async function watchDevFiles(devConfig, buildManager, root) {
+    let { watchFiles } = devConfig;
+    if (!watchFiles) return;
+    let watchers = [];
+    for (let { paths, options, type } of helpers_castArray(watchFiles)){
+        let watchOptions = prepareWatchOptions(paths, options, type), watcher = await startWatchFiles(watchOptions, buildManager, root);
+        watcher && watchers.push(watcher);
+    }
+    return async ()=>{
+        for (let watcher of watchers)await watcher.close();
+    };
+}
+function watchServerFiles({ publicDir }, buildManager, root) {
+    if (!publicDir.length) return;
+    let watchPaths = publicDir.filter((item)=>item.watch).map((item)=>item.name);
+    if (watchPaths.length) return startWatchFiles(prepareWatchOptions(watchPaths), buildManager, root);
+}
+function prepareWatchOptions(paths, options = {}, type) {
+    return {
+        paths: 'string' == typeof paths ? [
+            paths
+        ] : paths,
+        options,
+        type
+    };
+}
+let GLOB_REGEX = /[*?{}[\]()!+|]/;
+async function createChokidar(pathOrGlobs, root, options) {
+    let { default: chokidar } = await import("./chokidar.js"), watchFiles = new Set(), globPatterns = pathOrGlobs.filter((pathOrGlob)=>!!GLOB_REGEX.test(pathOrGlob) || (watchFiles.add(pathOrGlob), !1));
+    if (globPatterns.length) {
+        let { glob } = await import("./tinyglobby.js");
+        for (let file of (await glob(globPatterns, {
+            cwd: root,
+            absolute: !0
+        })))watchFiles.add(file);
+    }
+    return chokidar.watch(Array.from(watchFiles), options);
+}
+async function startWatchFiles({ paths, options, type = 'reload-page' }, buildManager, root) {
+    if ('reload-page' !== type) return;
+    let watcher = await createChokidar(paths, root, options);
+    return watcher.on('change', ()=>{
+        buildManager.socketServer.sendMessage({
+            type: 'full-reload'
+        });
+    }), watcher;
+}
+let requestRestart = ({ filePath, clear = !0, action, logger, restartManager })=>{
+    if (restartManager.canRestart) {
+        clear && isTTY() && !process.env.DEBUG && process.stdout.write('\x1B[H\x1B[2J');
+        let id = 'dev' === action ? 'server' : 'build';
+        if (filePath) {
+            let filename = node_path.basename(filePath);
+            logger.info(`restarting ${id} as ${color.yellow(filename)} changed\n`);
+        } else logger.info(`restarting ${id}...\n`);
+    }
+    return restartManager.requestRestart({
+        action,
+        filePath
+    });
+};
+function watchFilesForRestart({ watchFiles, context, action }) {
+    let closePromise, defaultFiles = context.configFile ? [
+        context.configFile,
+        ...context.configFileDependencies
+    ] : [];
+    if (!watchFiles.length && !defaultFiles.length) return;
+    let watchGroups = [];
+    for (let { paths, options, type } of watchFiles){
+        if ('restart' !== type && 'reload-server' !== type) continue;
+        let files = helpers_castArray(paths);
+        files.length && (options ? watchGroups.push({
+            files,
+            options
+        }) : defaultFiles.push(...files));
+    }
+    if (defaultFiles.length && watchGroups.push({
+        files: defaultFiles
+    }), !watchGroups.length) return;
+    let { logger, restartManager, rootPath: root } = context, restarting = !1, onChange = async (filePath, cwd)=>{
+        if (restarting || closePromise) return;
+        restarting = !0;
+        let absoluteFilePath = node_path.resolve(cwd, filePath);
+        try {
+            await requestRestart({
+                action,
+                filePath: absoluteFilePath,
+                logger,
+                restartManager
+            }) ? await close() : restartManager.canRestart && logger.error('build' === action ? 'Restart build failed.' : 'Restart server failed.');
+        } catch (error) {
+            logger.error(error);
+        } finally{
+            restarting = !1;
+        }
+    }, watchersPromise = Promise.all(watchGroups.map(async ({ files, options })=>{
+        try {
+            let watcher = await createChokidar(files, root, {
+                ignoreInitial: !0,
+                ignorePermissionErrors: !0,
+                ...options
+            }), cwd = options?.cwd || root, handleChange = (filePath)=>void onChange(filePath, cwd);
+            return watcher.on('add', handleChange), watcher.on('change', handleChange), watcher.on('unlink', handleChange), watcher;
+        } catch (error) {
+            logger.error(error);
+        }
+    })), close = ()=>(closePromise || (closePromise = watchersPromise.then((watchers)=>Promise.all(watchers.map((watcher)=>watcher?.close()))).then(()=>{})), closePromise);
+    return {
+        close
+    };
+}
 let RSPACK_BUILD_ERROR = 'Rspack build failed.', build_build = async (initOptions, { watch } = {})=>{
-    let { context } = initOptions, { logger } = context, { compiler, rspackConfigs } = await createCompiler_createCompiler(initOptions);
+    let stats, closeCompiler, closingPromise, unregisterRestart, restartWatcher, { context } = initOptions, { logger } = context, { compiler, rspackConfigs } = await createCompiler_createCompiler(initOptions);
     if ((({ context, isWatch, compiler, rspackConfigs, MultiStatsCtor })=>{
         let isFirstCompile = !0, { environmentList } = context, onDone = async (stats)=>{
             let promise = context.hooks.onAfterBuild.callBatch({
@@ -4316,28 +4374,32 @@ let RSPACK_BUILD_ERROR = 'Rspack build failed.', build_build = async (initOption
         MultiStatsCtor: core_rspack.MultiStats
     }), watch) {
         let watchOptions = rspackConfigs.map((options)=>options.watchOptions || {});
-        return compiler.watch(watchOptions.length > 1 ? watchOptions : watchOptions[0] || {}, (err)=>{
+        compiler.watch(watchOptions.length > 1 ? watchOptions : watchOptions[0] || {}, (err)=>{
             err && logger.error(err);
-        }), {
-            close: ()=>new Promise((resolve)=>{
-                    compiler.close(()=>{
-                        resolve();
-                    });
-                })
-        };
-    }
-    let { stats } = await new Promise((resolve, reject)=>{
+        }), closeCompiler = ()=>new Promise((resolve)=>{
+                compiler.close(()=>{
+                    resolve();
+                });
+            });
+    } else stats = await new Promise((resolve, reject)=>{
         compiler.run((err, stats)=>{
             compiler.close((closeErr)=>{
-                closeErr && logger.error('Failed to close compiler: ', closeErr), err ? reject(err) : context.buildState.hasErrors ? reject(Error(RSPACK_BUILD_ERROR)) : resolve({
-                    stats
-                });
+                closeErr && logger.error('Failed to close compiler: ', closeErr), err ? reject(err) : context.buildState.hasErrors ? reject(Error(RSPACK_BUILD_ERROR)) : resolve(stats);
             });
         });
     });
-    return {
+    let closeBuild = ()=>closingPromise ||= (async ()=>{
+            unregisterRestart?.(), unregisterRestart = void 0, await context.hooks.onCloseBuild.callBatch(), await closeCompiler?.();
+        })();
+    return watch && (unregisterRestart = context.restartManager.registerCleanup(closeBuild), restartWatcher = watchFilesForRestart({
+        watchFiles: context.normalizedConfig.dev.watchFiles,
+        context,
+        action: 'build'
+    })), {
         stats,
-        close: async ()=>{}
+        close: async ()=>{
+            await restartWatcher?.close(), await closeBuild();
+        }
     };
 }, main = __webpack_require__("../../node_modules/.pnpm/dotenv-expand@13.0.0_patch_hash=5ff37847fa487be2db4e4f14c2b21937f4e51cc7a43deea4506d4aaf3fa6149c/node_modules/dotenv-expand/lib/main.js"), DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function loadEnv_parse(src) {
@@ -4856,7 +4918,7 @@ function getRegExpForExts(exts) {
 function getCacheDirectory({ cacheDirectory }, context) {
     return cacheDirectory ? external_node_path_isAbsolute(cacheDirectory) ? cacheDirectory : join(context.rootPath, cacheDirectory) : join(context.cachePath, 'rspack');
 }
-async function getBuildDependencies(context, config, environmentContext, additionalDependencies) {
+async function getBuildDependencies(context, environmentContext, additionalDependencies) {
     let rootPackageJson = join(context.rootPath, 'package.json'), browserslistConfig = join(context.rootPath, '.browserslistrc'), buildDependencies = {};
     await isFileExists(rootPackageJson) && (buildDependencies.packageJson = [
         rootPackageJson
@@ -4864,8 +4926,9 @@ async function getBuildDependencies(context, config, environmentContext, additio
     let { tsconfigPath } = environmentContext;
     tsconfigPath && (buildDependencies.tsconfig = [
         tsconfigPath
-    ]), config._privateMeta?.configFilePath && (buildDependencies.rsbuildConfig = [
-        config._privateMeta.configFilePath
+    ]), context.configFile && (buildDependencies.rsbuildConfig = [
+        context.configFile,
+        ...context.configFileDependencies
     ]), await isFileExists(browserslistConfig) && (buildDependencies.browserslistrc = [
         browserslistConfig
     ]);
@@ -4953,7 +5016,7 @@ function parseMinifyOptions(config) {
         cssOptions: minify.cssOptions
     };
 }
-let postcss_load_config_src = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16/node_modules/postcss-load-config/src/index.js");
+let postcss_load_config_src = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.19/node_modules/postcss-load-config/src/index.js");
 var postcss_load_config_src_default = __webpack_require__.n(postcss_load_config_src);
 async function getLightningCSSLoaderOptions(config, targets, minify) {
     let userOptions = 'object' == typeof config.tools.lightningcssLoader ? config.tools.lightningcssLoader : {}, initialOptions = {
@@ -5205,7 +5268,7 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
     if (!showTotal && !showDetail) return {
         logs
     };
-    let relativeDistPath = node_path.relative(rootPath, distPath), snapshot = saveSnapshot ? {
+    let relativeDistPath = node_path.relative(rootPath, distPath), rootFolderLabel = `${relativeDistPath || '.'}${node_path.sep}`, snapshot = saveSnapshot ? {
         files: {},
         totalSize: 0,
         totalGzipSize: 0
@@ -5227,7 +5290,7 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
                 isSignificantDiff(gzipDiff) && (gzipSizeLabel += ` ${formatDiff(gzipDiff).label}`);
             }
         }
-        let separatorIndex = filePath.lastIndexOf('/'), folderLabel = (-1 === separatorIndex ? node_path.join(relativeDistPath, '.') : node_path.join(relativeDistPath, filePath.slice(0, separatorIndex))) + node_path.sep, filename = -1 === separatorIndex ? filePath : filePath.slice(separatorIndex + 1);
+        let separatorIndex = filePath.lastIndexOf('/'), folderLabel = -1 === separatorIndex ? rootFolderLabel : `${node_path.join(relativeDistPath, filePath.slice(0, separatorIndex))}${node_path.sep}`, filename = -1 === separatorIndex ? filePath : filePath.slice(separatorIndex + 1);
         return {
             filePath,
             filenameLabel: color.dim(folderLabel) + (JS_REGEX.test(filename) ? color.cyan(filename) : filename.endsWith('.css') ? color.yellow(filename) : filename.endsWith('.html') ? color.green(filename) : color.magenta(filename)),
@@ -5916,6 +5979,8 @@ async function open_open({ port, routes, config, protocol, clearCache, logger })
     for (let url of (targets.length ? urls.push(...targets.map((target)=>resolveUrl(replacePortPlaceholder(target, port), baseUrl))) : routes.length ? urls.push(`${baseUrl}${routes[0].pathname}`) : urls.push(baseUrl), before && await before(), urls))openedURLs.includes(url) || (openBrowser(url, logger), openedURLs.push(url));
 }
 let getServerUrlFromClientConfig = async (config, context)=>{
+    let { assetPrefix } = config.dev;
+    if (!(!0 === assetPrefix || 'string' == typeof assetPrefix && isURL(assetPrefix))) return;
     let { devServer } = context;
     if (!devServer) return;
     let { client } = config.dev, hasClientHost = !!client.host, hasClientPort = void 0 !== client.port && '' !== client.port;
@@ -6727,7 +6792,7 @@ function createAssetsMiddleware(context, ready, outputFileSystem) {
 }
 async function setupOutputFileSystem(writeToDisk, compilers) {
     if (!0 !== writeToDisk) {
-        let { createFsFromVolume, Volume } = await import("./memfs.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/memfs@4.57.8/node_modules/memfs/lib/index.js", 23)), outputFileSystem = createFsFromVolume(new Volume());
+        let { createFsFromVolume, Volume } = await import("./memfs.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/memfs@4.64.0/node_modules/memfs/lib/index.js", 23)), outputFileSystem = createFsFromVolume(new Volume());
         for (let compiler of compilers)compiler.outputFileSystem = outputFileSystem;
     }
     let compiler = compilers.find((compiler)=>!!compiler.outputFileSystem);
@@ -8009,14 +8074,15 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>{
     });
 }, createCacheableFunction = (getter)=>{
     let cache = new WeakMap();
-    return async (stats, entryName, utils)=>{
+    return (stats, entryName, utils)=>{
         let cachedEntries = cache.get(stats);
-        if (cachedEntries?.[entryName]) return cachedEntries[entryName];
-        let res = await getter(stats, entryName, utils);
-        return cache.set(stats, {
-            ...cachedEntries || {},
-            [entryName]: res
-        }), res;
+        cachedEntries || (cachedEntries = new Map(), cache.set(stats, cachedEntries));
+        let cachedPromise = cachedEntries.get(entryName);
+        if (cachedPromise) return cachedPromise;
+        let promise = Promise.resolve().then(()=>getter(stats, entryName, utils)).catch((error)=>{
+            throw cachedEntries.delete(entryName), error;
+        });
+        return cachedEntries.set(entryName, promise), promise;
     };
 }, cleanupCallbacks = new Set(), handleTermination = async (exitCode)=>{
     try {
@@ -8062,69 +8128,9 @@ async function applyServerSetup(setup, context) {
     }
     return postCallbacks;
 }
-async function setupWatchFiles(options) {
-    let { config, root, buildManager } = options, { hmr, liveReload } = config.dev;
-    if (!hmr && !liveReload || !buildManager) return;
-    let closeDevFilesWatcher = await watchDevFiles(config.dev, buildManager, root), serverFilesWatcher = await watchServerFiles(config.server, buildManager, root);
-    return {
-        async close () {
-            await Promise.all([
-                closeDevFilesWatcher?.(),
-                serverFilesWatcher?.close()
-            ]);
-        }
-    };
-}
-async function watchDevFiles(devConfig, buildManager, root) {
-    let { watchFiles } = devConfig;
-    if (!watchFiles) return;
-    let watchers = [];
-    for (let { paths, options, type } of helpers_castArray(watchFiles)){
-        let watchOptions = prepareWatchOptions(paths, options, type), watcher = await startWatchFiles(watchOptions, buildManager, root);
-        watcher && watchers.push(watcher);
-    }
-    return async ()=>{
-        for (let watcher of watchers)await watcher.close();
-    };
-}
-function watchServerFiles({ publicDir }, buildManager, root) {
-    if (!publicDir.length) return;
-    let watchPaths = publicDir.filter((item)=>item.watch).map((item)=>item.name);
-    if (watchPaths.length) return startWatchFiles(prepareWatchOptions(watchPaths), buildManager, root);
-}
-function prepareWatchOptions(paths, options = {}, type) {
-    return {
-        paths: 'string' == typeof paths ? [
-            paths
-        ] : paths,
-        options,
-        type
-    };
-}
-let GLOB_REGEX = /[*?{}[\]()!+|]/;
-async function createChokidar(pathOrGlobs, root, options) {
-    let { default: chokidar } = await import("./chokidar.js"), watchFiles = new Set(), globPatterns = pathOrGlobs.filter((pathOrGlob)=>!!GLOB_REGEX.test(pathOrGlob) || (watchFiles.add(pathOrGlob), !1));
-    if (globPatterns.length) {
-        let { glob } = await import("./tinyglobby.js");
-        for (let file of (await glob(globPatterns, {
-            cwd: root,
-            absolute: !0
-        })))watchFiles.add(file);
-    }
-    return chokidar.watch(Array.from(watchFiles), options);
-}
-async function startWatchFiles({ paths, options, type = 'reload-page' }, buildManager, root) {
-    if ('reload-page' !== type) return;
-    let watcher = await createChokidar(paths, root, options);
-    return watcher.on('change', ()=>{
-        buildManager.socketServer.sendMessage({
-            type: 'full-reload'
-        });
-    }), watcher;
-}
 async function devServer_createDevServer(options, createCompiler, config, { getPortSilently, runCompile = !0 } = {}) {
     var environmentCount;
-    let stats, waiters, { context } = options, { logger } = context;
+    let closingPromise, unregisterRestart, stats, waiters, { context } = options, { logger } = context;
     logger.debug('create dev server');
     let { port, portTip } = await resolvePort(config), { middlewareMode, host } = config.server, isHttps = !!config.server.https, routes = getRoutes(context), fallbackPathname = 0 === routes.length && context.environmentList.some((item)=>'web' === item.config.output.target) ? config.server.base : void 0;
     context.devServer = {
@@ -8195,12 +8201,22 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
             protocol,
             clearCache: !0,
             logger
-        }), state = {}, cleanupGracefulShutdown = middlewareMode ? null : setupGracefulShutdown(), closingPromise = null, closeServer = async ()=>(closingPromise || (closingPromise = (async ()=>{
+        }), state = {}, cleanupGracefulShutdown = middlewareMode ? null : setupGracefulShutdown(), closeServerResources = ()=>(closingPromise || (unregisterRestart?.(), unregisterRestart = void 0, closingPromise = (async ()=>{
             removeCleanup(closeServer), cleanupGracefulShutdown?.(), await context.hooks.onCloseDevServer.callBatch(), await Promise.all([
                 state.devMiddlewares?.close(),
                 state.fileWatcher?.close()
             ]);
-        })()), closingPromise);
+        })()), closingPromise), closeServer = async ()=>{
+        await state.restartWatcher?.close(), await closeServerResources();
+    }, restartServer = async ()=>{
+        let restarted = await requestRestart({
+            action: 'dev',
+            clear: !1,
+            logger,
+            restartManager: context.restartManager
+        });
+        return restarted && await state.restartWatcher?.close(), restarted;
+    };
     middlewareMode || registerCleanup(closeServer);
     let beforeCreateCompiler = async ()=>{
         if (printUrls(), cliShortcutsEnabled) {
@@ -8208,10 +8224,7 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
                 openPage,
                 closeServer,
                 printUrls,
-                restartServer: ()=>restartDevServer({
-                        clear: !1,
-                        logger
-                    }),
+                restartServer: context.restartManager.canRestart ? restartServer : void 0,
                 help: shortcutsOptions.help,
                 customShortcuts: shortcutsOptions.custom,
                 logger
@@ -8272,7 +8285,7 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
                     port
                 }, async (err)=>{
                     if (err) throw err;
-                    middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), state.devMiddlewares && httpServer.on('upgrade', state.devMiddlewares.onUpgrade), logger.debug('listen dev server done'), await devServer.afterListen(), onBeforeRestartServer(devServer.close), resolve({
+                    middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), state.devMiddlewares && httpServer.on('upgrade', state.devMiddlewares.onUpgrade), logger.debug('listen dev server done'), await devServer.afterListen(), resolve({
                         port,
                         urls: urls.map((item)=>item.url),
                         server: devServer
@@ -8314,7 +8327,11 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
         devServer,
         context,
         postCallbacks
-    }), state.buildManager?.watch(), logger.debug('create dev server done'), devServer;
+    }), state.buildManager?.watch(), unregisterRestart = context.restartManager.registerCleanup(closeServerResources), state.restartWatcher = watchFilesForRestart({
+        watchFiles: config.dev.watchFiles,
+        context,
+        action: 'dev'
+    }), logger.debug('create dev server done'), devServer;
 }
 async function startPreviewServer(context, config, { getPortSilently } = {}) {
     let environmentList, { logger } = context, { connect } = await import("./connect-next.js"), middlewares = connect(), { port, portTip } = await resolvePort(config), serverConfig = config.server, { host, headers, proxy, historyApiFallback, compress, base, cors } = serverConfig, assetPrefixes = context.environmentList.map((environment)=>environment.config.output.assetPrefix);
@@ -8546,7 +8563,7 @@ function applyDefaultPlugins(pluginManager, context) {
                     let { config } = environment, { buildCache = !1 } = config.performance;
                     if (!1 === buildCache) return;
                     cacheEnabled = !0;
-                    let { context } = api, cacheConfig = 'boolean' == typeof buildCache ? {} : buildCache, cacheDirectory = getCacheDirectory(cacheConfig, context), buildDependencies = await getBuildDependencies(context, config, environment, cacheConfig.buildDependencies), cacheVersion = Array.isArray(cacheConfig.cacheDigest) && cacheConfig.cacheDigest.length ? `${environment.name}-${env}-${await helpers_hash(JSON.stringify(cacheConfig.cacheDigest))}` : `${environment.name}-${env}`;
+                    let { context } = api, cacheConfig = 'boolean' == typeof buildCache ? {} : buildCache, cacheDirectory = getCacheDirectory(cacheConfig, context), buildDependencies = await getBuildDependencies(context, environment, cacheConfig.buildDependencies), cacheVersion = Array.isArray(cacheConfig.cacheDigest) && cacheConfig.cacheDigest.length ? `${environment.name}-${env}-${await helpers_hash(JSON.stringify(cacheConfig.cacheDigest))}` : `${environment.name}-${env}`;
                     chain.cache({
                         type: 'persistent',
                         version: cacheVersion,
@@ -8671,7 +8688,7 @@ function applyDefaultPlugins(pluginManager, context) {
                     let showDiff = environments.some((environment)=>{
                         let { printFileSize } = environment.config.performance;
                         return 'object' == typeof printFileSize && !!printFileSize.diff;
-                    }), { configFilePath } = api.getNormalizedConfig()._privateMeta || {}, snapshotHash = showDiff && configFilePath ? await helpers_hash(configFilePath) : '', snapshotPath = showDiff ? getSnapshotPath(api.context.cachePath, snapshotHash) : '', prevSnapshots = showDiff ? await loadPrevSnapshots(snapshotPath) : null, nextSnapshots = {}, logs = await Promise.all(environments.map(async ({ name, index, config, distPath })=>{
+                    }), { configFile } = api.context, snapshotHash = showDiff && configFile ? await helpers_hash(configFile) : '', snapshotPath = showDiff ? getSnapshotPath(api.context.cachePath, snapshotHash) : '', prevSnapshots = showDiff ? await loadPrevSnapshots(snapshotPath) : null, nextSnapshots = {}, logs = await Promise.all(environments.map(async ({ name, index, config, distPath })=>{
                         let statsItem = 'stats' in stats ? stats.stats[index] : stats, { logs: sizeLogs, snapshot } = await printFileSizes(((config)=>{
                             let { printFileSize } = config.performance, defaultConfig = {
                                 total: !0,
@@ -9163,9 +9180,16 @@ try {
             setup (api) {
                 api.modifyBundlerChain(async (chain, { environment, CHAIN_ID, rspack })=>{
                     let { config } = environment, { minifyJs, minifyCss, jsOptions, cssOptions } = parseMinifyOptions(config);
-                    if (chain.optimization.minimize(minifyJs || minifyCss), minifyJs && chain.optimization.minimizer(CHAIN_ID.MINIMIZER.JS).use(rspack.SwcJsMinimizerRspackPlugin, [
-                        getSwcMinimizerOptions(config, jsOptions)
-                    ]).end(), minifyCss) {
+                    if (chain.optimization.minimize(minifyJs || minifyCss), minifyJs) {
+                        let registerJsMinimizer = (jsOptionsItem, index = 0)=>{
+                            let minimizerId = 0 === index ? CHAIN_ID.MINIMIZER.JS : `${CHAIN_ID.MINIMIZER.JS}-${index}`;
+                            chain.optimization.minimizer(minimizerId).use(rspack.SwcJsMinimizerRspackPlugin, [
+                                getSwcMinimizerOptions(config, jsOptionsItem)
+                            ]).end();
+                        }, jsOptionsList = helpers_castArray(jsOptions);
+                        jsOptionsList.length > 0 ? jsOptionsList.forEach(registerJsMinimizer) : registerJsMinimizer();
+                    }
+                    if (minifyCss) {
                         let loaderOptions = await getLightningCSSLoaderOptions(config, environment.browserslist, !0), defaultOptions = {
                             minimizerOptions: {
                                 targets: isPlainObject(loaderOptions.targets) ? environment.browserslist : loaderOptions.targets,
@@ -9527,7 +9551,7 @@ try {
                 api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, isDev })=>{
                     let { output: { manifest }, dev: { writeToDisk } } = environment.config;
                     if (!1 === manifest) return;
-                    let manifestOptions = normalizeManifestObjectConfig(manifest), { RspackManifestPlugin } = await import("./manifest-plugin.js").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.2_@rspack+core@2.1.3/node_modules/rspack-manifest-plugin/dist/index.js")), { htmlPaths } = environment, filter = manifestOptions.filter ?? ((file)=>!file.name.endsWith('.LICENSE.txt'));
+                    let manifestOptions = normalizeManifestObjectConfig(manifest), { RspackManifestPlugin } = await import("./manifest-plugin.js").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.2_@rspack+core@2.1.5/node_modules/rspack-manifest-plugin/dist/index.js")), { htmlPaths } = environment, filter = manifestOptions.filter ?? ((file)=>!file.name.endsWith('.LICENSE.txt'));
                     manifestFilenames.set(environment.name, manifestOptions.filename);
                     let pluginOptions = {
                         fileName: manifestOptions.filename,
@@ -9714,7 +9738,7 @@ function applyEnvsToConfig(config, envs) {
         ...config.dev.watchFiles ? helpers_castArray(config.dev.watchFiles) : [],
         {
             paths: envs.filePaths,
-            type: 'reload-server'
+            type: 'restart'
         }
     ], config.performance?.buildCache))) {
         let { buildCache } = config.performance;
@@ -9723,11 +9747,16 @@ function applyEnvsToConfig(config, envs) {
         } : (buildCache.buildDependencies ||= [], buildCache.buildDependencies.push(...envs.filePaths));
     }
 }
+function isLoadConfigResult(result) {
+    return 'object' == typeof result && null !== result && 'content' in result && 'filePath' in result && 'dependencies' in result;
+}
 async function createRsbuild(options = {}) {
-    let envs = options.loadEnv ? loadEnv({
+    let loadConfigResult, envs = options.loadEnv ? loadEnv({
         cwd: options.cwd,
         ...'boolean' == typeof options.loadEnv ? {} : options.loadEnv
-    }) : null, configOrFactory = options.config ?? options.rsbuildConfig, config = isFunction(configOrFactory) ? await configOrFactory() : configOrFactory || {}, logger = config.customLogger ?? logger_createLogger({
+    }) : null, configOrFactory = options.config ?? options.rsbuildConfig, config = isFunction(configOrFactory) ? await configOrFactory() : configOrFactory;
+    isLoadConfigResult(config) && (loadConfigResult = config, config = config.content);
+    let logger = (config ||= {}).customLogger ?? logger_createLogger({
         ...src_logger.options,
         level: src_logger.level
     });
@@ -9737,7 +9766,7 @@ async function createRsbuild(options = {}) {
         callerName: 'rsbuild',
         ...options,
         rsbuildConfig: config
-    }, pluginManager = createPluginManager(logger), context = await createContext(resolvedOptions, config, logger), getPluginAPI = initPluginAPI({
+    }, pluginManager = createPluginManager(logger), context = await createContext(resolvedOptions, config, logger, loadConfigResult), getPluginAPI = initPluginAPI({
         context,
         pluginManager
     });
@@ -9759,20 +9788,11 @@ async function createRsbuild(options = {}) {
             if (isEmptyDir(distPath)) throw Error(`${color.dim('[rsbuild:preview]')} The output directory ${color.yellow(distPath)} is empty, please build the project before previewing.`);
         }
         return startPreviewServer(context, config, options);
-    }, build = async (options)=>{
-        context.action = 'build', process.env.NODE_ENV || setNodeEnv('production');
-        let buildInstance = await build_build({
+    }, build = async (options)=>(context.action = 'build', process.env.NODE_ENV || setNodeEnv('production'), build_build({
             context,
             pluginManager,
             rsbuildOptions: resolvedOptions
-        }, options);
-        return {
-            ...buildInstance,
-            close: async ()=>{
-                await context.hooks.onCloseBuild.callBatch(), await buildInstance.close();
-            }
-        };
-    }, startDevServer = async (options)=>{
+        }, options)), startDevServer = async (options)=>{
         context.action = 'dev', process.env.NODE_ENV || setNodeEnv('development');
         let config = await initRsbuildConfig({
             context,
@@ -9859,7 +9879,8 @@ async function createRsbuild(options = {}) {
             'onCloseBuild',
             'onCloseDevServer',
             'onDevCompileDone',
-            'onExit'
+            'onExit',
+            'onRestart'
         ])
     };
     envs && (rsbuild.onCloseBuild(envs.cleanup), rsbuild.onCloseDevServer(envs.cleanup));
@@ -9881,61 +9902,59 @@ async function createRsbuild(options = {}) {
         });
     })), rsbuild;
 }
-function defineConfig(config) {
-    return config;
-}
-let DEFAULT_CONFIG_FILE_NAMES = [
-    'rsbuild.config.ts',
-    'rsbuild.config.js',
-    'rsbuild.config.mts',
-    'rsbuild.config.mjs',
-    'rsbuild.config.cts',
-    'rsbuild.config.cjs'
-], canReadExport = (module)=>null !== module && ('object' == typeof module || 'function' == typeof module), getConfigExport = (configModule, exportName, configFilePath)=>{
+let canReadExport = (module)=>null !== module && ('object' == typeof module || 'function' == typeof module), getConfigExport = (configModule, exportName, configPath)=>{
     if (!1 === exportName) return {};
     if ('default' === exportName) return canReadExport(configModule) && 'default' in configModule ? configModule.default : configModule;
     if (canReadExport(configModule) && Object.hasOwn(configModule, exportName)) return configModule[exportName];
-    throw Error(`Cannot find export ${color.yellow(exportName)} in config file: ${color.dim(configFilePath)}`);
-}, tryFreshImport = async (configFileURL)=>{
+    throw Error(`Cannot find export ${exportName} in config file: ${configPath}`);
+}, loadWithJiti = async (configPath, exportName, fresh)=>{
+    let createJiti;
     try {
-        let { freshImport } = await import("./fresh-import.js");
-        return await freshImport(configFileURL);
-    } catch (err) {
-        src_logger.debug('failed to initialize fresh-import, fallback to dynamic import.'), src_logger.debug(err);
+        ({ createJiti } = await import("../compiled/jiti/lib/jiti.mjs"));
+    } catch (error) {
+        throw Error('The "jiti" package is required to load this config. Install it with your package manager.', {
+            cause: error
+        });
     }
-}, loadConfigWithNative = async (configFilePath)=>{
-    let configFileURL = pathToFileURL(configFilePath).href, freshImportResult = await tryFreshImport(configFileURL);
-    return freshImportResult ? {
-        configModule: freshImportResult.result,
-        dependencies: freshImportResult.dependencies.sort()
-    } : {
-        configModule: await import(`${configFileURL}?t=${Date.now()}`),
-        dependencies: []
-    };
-}, loadConfigWithJiti = async (configFilePath, exportName)=>{
-    let { createJiti } = await import("../compiled/jiti/lib/jiti.mjs"), jiti = createJiti(import.meta.filename, {
-        moduleCache: !1,
+    let jiti = createJiti(configPath, {
+        moduleCache: !fresh,
         interopDefault: !0,
         nativeModules: [
             "typescript"
         ]
     });
     return 'default' === exportName ? {
-        configExport: await jiti.import(configFilePath, {
+        configExport: await jiti.import(configPath, {
             default: !0
         }),
         dependencies: []
     } : {
-        configExport: getConfigExport(await jiti.import(configFilePath), exportName, configFilePath),
+        configExport: getConfigExport(await jiti.import(configPath), exportName, configPath),
+        dependencies: []
+    };
+}, JS_CONFIG_REGEXP = /\.(?:js|mjs|cjs)$/, loadWithNative = async (configPath, fresh)=>{
+    let configFileURL = pathToFileURL(configPath).href;
+    if (!fresh) return {
+        configModule: await import(configFileURL),
+        dependencies: []
+    };
+    let { freshImport } = await import("./freshImport.js"), freshImportResult = await freshImport(configFileURL);
+    return freshImportResult ? {
+        configModule: freshImportResult.result,
+        dependencies: freshImportResult.dependencies.sort()
+    } : {
+        configModule: await import(`${configFileURL}?t=${Date.now()}`),
         dependencies: []
     };
 };
-async function loadConfig_loadConfig({ cwd = process.cwd(), path, configFileNames, envMode, meta, loader = 'auto', command, exportName = 'default' } = {}) {
-    let loadedConfig, configFilePath = ((root, customConfig, configFileNames = DEFAULT_CONFIG_FILE_NAMES)=>{
+async function dist_loadConfig({ cwd = process.cwd(), path, configFileNames = [], loader = 'auto', exportName = 'default', configParams = [], fresh = !1 } = {}) {
+    let loadedConfig;
+    if (!path && 0 === configFileNames.length) throw Error('Either `path` or at least one `configFileNames` entry must be provided.');
+    let configPath = ((root, customConfig, configFileNames = [])=>{
         if (customConfig) {
             let customConfigPath = external_node_path_isAbsolute(customConfig) ? customConfig : join(root, customConfig);
             if (node_fs.existsSync(customConfigPath)) return customConfigPath;
-            throw Error(`Cannot find config file: ${color.dim(customConfigPath)}`);
+            throw Error(`Cannot find config file: ${customConfigPath}`);
         }
         for (let file of configFileNames){
             let configFile = join(root, file);
@@ -9943,67 +9962,87 @@ async function loadConfig_loadConfig({ cwd = process.cwd(), path, configFileName
         }
         return null;
     })(cwd, path, configFileNames);
-    if (!configFilePath) return src_logger.debug('no config file found.'), {
+    if (!configPath) return {
         content: {},
-        filePath: configFilePath,
+        filePath: configPath,
         dependencies: []
     };
-    let applyMetaInfo = (config)=>(config._privateMeta = {
-            configFilePath
-        }, config);
-    if ('native' === loader || 'auto' === loader && (process.features.typescript || process.versions.bun || process.versions.deno) || /\.(?:js|mjs|cjs)$/.test(configFilePath)) {
+    if ('native' === loader || 'auto' === loader && (process.features.typescript || process.versions.bun || process.versions.deno) || JS_CONFIG_REGEXP.test(configPath)) {
         let result;
         try {
-            result = await loadConfigWithNative(configFilePath);
+            result = await loadWithNative(configPath, fresh);
         } catch (err) {
-            let errorMessage = `Failed to load file with native loader: ${color.dim(configFilePath)}`;
-            if ('native' === loader) throw src_logger.error(errorMessage), err;
-            src_logger.debug(`${errorMessage}, fallback to jiti.`), src_logger.debug(err);
+            if ('native' === loader) throw err;
         }
         result && (loadedConfig = {
-            configExport: getConfigExport(result.configModule, exportName, configFilePath),
+            configExport: getConfigExport(result.configModule, exportName, configPath),
             dependencies: result.dependencies
         });
     }
-    if (!loadedConfig) try {
-        loadedConfig = await loadConfigWithJiti(configFilePath, exportName);
-    } catch (err) {
-        throw src_logger.error(`Failed to load file with jiti: ${color.dim(configFilePath)}`), err;
-    }
+    loadedConfig || (loadedConfig = await loadWithJiti(configPath, exportName, fresh));
     let { configExport, dependencies } = loadedConfig;
     if ('function' == typeof configExport) {
-        let nodeEnv = process.env.NODE_ENV || '', configParams = {
-            env: nodeEnv,
-            command: command ?? process.argv[2],
-            envMode: envMode || nodeEnv,
-            meta
-        }, result = await configExport(configParams);
+        let result = await configExport(...configParams);
         if (void 0 === result) throw Error('The config function must return a config object.');
         return {
-            content: applyMetaInfo(result),
-            filePath: configFilePath,
+            content: result,
+            filePath: configPath,
             dependencies
         };
     }
-    if (!isObject(configExport)) throw Error(`The config must be an object or a function that returns an object, get ${color.yellow(String(configExport))}`);
-    return src_logger.debug('configuration loaded from:', configFilePath), {
-        content: applyMetaInfo(configExport),
-        filePath: configFilePath,
+    return {
+        content: configExport,
+        filePath: configPath,
         dependencies
     };
 }
+function defineConfig(config) {
+    return config;
+}
+let DEFAULT_CONFIG_FILE_NAMES = [
+    'rsbuild.config.ts',
+    'rsbuild.config.js',
+    'rsbuild.config.mts',
+    'rsbuild.config.mjs',
+    'rsbuild.config.cts',
+    'rsbuild.config.cjs'
+];
+async function loadConfig_loadConfig({ cwd = process.cwd(), path, configFileNames = DEFAULT_CONFIG_FILE_NAMES, envMode, meta, loader = 'auto', command, exportName = 'default' } = {}) {
+    let nodeEnv = process.env.NODE_ENV || '', configParams = {
+        env: nodeEnv,
+        command: command ?? process.argv[2],
+        envMode: envMode || nodeEnv,
+        meta
+    }, result = await dist_loadConfig({
+        cwd,
+        path,
+        configFileNames,
+        loader,
+        exportName,
+        configParams: [
+            configParams
+        ],
+        fresh: !0
+    });
+    if (!result.filePath) return src_logger.debug('no config file found.'), result;
+    if (!isObject(result.content)) throw Error(`The config must be an object or a function that returns an object, get ${color.yellow(String(result.content))}`);
+    return result.content._privateMeta = {
+        configFilePath: result.filePath,
+        configFileDependencies: result.dependencies
+    }, src_logger.debug('configuration loaded from:', result.filePath), result;
+}
 let cliState = {
     options: {}
 }, initCliAction = (command, options)=>{
     process.env.NODE_ENV || (process.env.NODE_ENV = 'build' === command || 'preview' === command ? 'production' : 'development'), options.environment?.some((env)=>env.includes(',')) && (options.environment = options.environment.flatMap((env)=>env.split(','))), cliState.command = command, cliState.options = options;
 }, init_loadConfig = async (root)=>{
-    let { options, command } = cliState, { content: config, filePath, dependencies } = await loadConfig_loadConfig({
+    let { options, command } = cliState, result = await loadConfig_loadConfig({
         cwd: root,
         path: options.config,
         envMode: options.envMode,
         loader: options.configLoader,
         command
-    });
+    }), { content: config } = result;
     if (config.dev ||= {}, config.source ||= {}, config.server ||= {}, options.base && (config.server.base = options.base), options.root && (config.root = root), options.mode && (config.mode = options.mode), options.logLevel && (config.logLevel = options.logLevel), options.open && !config.server?.open && (config.server.open = options.open), void 0 !== options.host && (config.server.host = options.host), options.port && (config.server.port = options.port), void 0 !== options.strictPort && (config.server.strictPort = options.strictPort), void 0 !== options.distPath) {
         config.output ||= {};
         let { distPath } = config.output;
@@ -10019,18 +10058,16 @@ let cliState = {
         if ('boolean' != typeof sourceMap) throw Error('The "--source-map" option only accepts a boolean value.');
         config.output ||= {}, config.output.sourceMap = sourceMap;
     }
-    return void 0 === config.dev.cliShortcuts && (config.dev.cliShortcuts = !0), filePath && (config.dev.watchFiles = [
-        ...config.dev.watchFiles ? helpers_castArray(config.dev.watchFiles) : [],
-        {
-            paths: [
-                filePath,
-                ...dependencies
-            ],
-            type: 'reload-server'
-        }
-    ]), config;
+    return void 0 === config.dev.cliShortcuts && (config.dev.cliShortcuts = !0), result;
+}, init_restart = async ({ action })=>{
+    let rsbuild = await init_init({
+        isRestart: !0
+    });
+    return !!rsbuild && ('build' === action ? await rsbuild.build({
+        watch: !0
+    }) : await rsbuild.startDevServer(), !0);
 };
-async function init_init({ isRestart, isBuildWatch = !1 } = {}) {
+async function init_init({ isRestart } = {}) {
     let logger = src_logger, { options } = cliState;
     try {
         var envDir;
@@ -10041,90 +10078,21 @@ async function init_init({ isRestart, isBuildWatch = !1 } = {}) {
             loadEnv: !1 !== options.env && {
                 cwd: (envDir = options.envDir) ? node_path.isAbsolute(envDir) ? envDir : node_path.join(root, envDir) : root,
                 mode: options.envMode
-            }
+            },
+            restart: init_restart
         });
-        return logger = rsbuild.logger, rsbuild.onBeforeCreateCompiler(()=>{
-            if ('dev' !== rsbuild.context.action && !isBuildWatch) return;
-            let files = [], config = rsbuild.getNormalizedConfig();
-            if (config.dev.watchFiles) for (let watchConfig of config.dev.watchFiles){
-                if ('reload-server' !== watchConfig.type) continue;
-                let paths = helpers_castArray(watchConfig.paths);
-                watchConfig.options ? watchFilesForRestart({
-                    files: paths,
-                    rsbuild,
-                    isBuildWatch,
-                    watchOptions: watchConfig.options
-                }) : files.push(...paths);
-            }
-            watchFilesForRestart({
-                files,
-                rsbuild,
-                isBuildWatch
-            });
-        }), rsbuild;
+        return logger = rsbuild.logger, rsbuild;
     } catch (err) {
         if (isRestart) logger.error(err);
         else throw err;
     }
 }
-let cleaners = [], onBeforeRestartServer = (cleaner)=>{
-    cleaners.push(cleaner);
-}, beforeRestart = async ({ filePath, clear = !0, id, logger })=>{
-    if (clear && isTTY() && !process.env.DEBUG && process.stdout.write('\x1B[H\x1B[2J'), filePath) {
-        let filename = node_path.basename(filePath);
-        logger.info(`restarting ${id} as ${color.yellow(filename)} changed\n`);
-    } else logger.info(`restarting ${id}...\n`);
-    for (let cleaner of cleaners)await cleaner();
-    cleaners = [];
-}, restartDevServer = async ({ filePath, clear = !0, logger })=>{
-    await beforeRestart({
-        filePath,
-        clear,
-        id: 'server',
-        logger
-    });
-    let rsbuild = await init_init({
-        isRestart: !0
-    });
-    return !!rsbuild && (await rsbuild.startDevServer(), !0);
-}, restartBuild = async ({ filePath, clear = !0, logger })=>{
-    await beforeRestart({
-        filePath,
-        clear,
-        id: 'build',
-        logger
-    });
-    let rsbuild = await init_init({
-        isRestart: !0,
-        isBuildWatch: !0
-    });
-    return !!rsbuild && (onBeforeRestartServer((await rsbuild.build({
-        watch: !0
-    })).close), !0);
-};
-async function watchFilesForRestart({ files, rsbuild, isBuildWatch, watchOptions }) {
-    if (!files.length) return;
-    let root = rsbuild.context.rootPath, watcher = await createChokidar(files, root, {
-        ignoreInitial: !0,
-        ignorePermissionErrors: !0,
-        ...watchOptions
-    }), restarting = !1, onChange = async (filePath)=>{
-        restarting || (restarting = !0, (isBuildWatch ? await restartBuild({
-            filePath,
-            logger: rsbuild.logger
-        }) : await restartDevServer({
-            filePath,
-            logger: rsbuild.logger
-        })) ? await watcher.close() : rsbuild.logger.error(isBuildWatch ? 'Restart build failed.' : 'Restart server failed.'), restarting = !1);
-    };
-    watcher.on('add', onChange), watcher.on('change', onChange), watcher.on('unlink', onChange);
-}
 let applyServerOptions = (command)=>{
     command.option('-o, --open [url]', 'Open the page in browser on startup').option('--port <port>', 'Set the port number for the server').option('--strict-port', 'Exit if the specified port is already in use').option('--host [host]', 'Set the host that the server listens to');
 };
 function setupCommands(argv) {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.1.5"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.1.7"), 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('--dist-path <dir>', 'Set the root directory of output files').option('--source-map', 'Enable source map').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: [
@@ -10148,15 +10116,13 @@ function setupCommands(argv) {
         initCliAction('build', options);
         try {
             options.watch || (process.env.RSPACK_UNSAFE_FAST_DROP = 'true');
-            let rsbuild = await init_init({
-                isBuildWatch: options.watch
-            });
+            let rsbuild = await init_init();
             if (!rsbuild) return;
             logger = rsbuild.logger;
             let buildResult = await rsbuild.build({
                 watch: options.watch
             });
-            buildResult && (options.watch ? onBeforeRestartServer(buildResult.close) : await buildResult.close());
+            options.watch || await buildResult.close();
         } catch (err) {
             err instanceof Error && err.message === RSPACK_BUILD_ERROR || logger.error('Failed to build.'), logger.error(err), process.exit(1);
         }
@@ -10183,12 +10149,15 @@ function setupCommands(argv) {
             logger.error('Failed to inspect config.'), logger.error(err), process.exit(1);
         }
     }), cli.help((sections)=>{
-        for (let section of (sections.shift(), sections))'Usage' === section.title && (section.body = section.body.replace('$ rsbuild', color.yellow("$ rsbuild [command] [options]"))), 'Commands' === section.title && (section.body = section.body.replace(`         ${devDescription}`, `dev      ${devDescription}`)), section.title?.startsWith('For more info') ? (section.title = color.dim('  For details on a sub-command, run'), section.body = color.dim('  $ rsbuild <command> -h')) : section.title && (section.title = color.cyan(section.title));
+        sections.shift();
+        let commandName = cli.matchedCommandName;
+        for (let section of sections = sections.filter(({ title })=>!commandName || 'Commands' !== title && !title?.startsWith('For more info')))'Usage' === section.title && (section.body = `  ${color.yellow(`$ rsbuild ${commandName || '[command]'} [options]`)}`), 'Commands' === section.title && (section.body = section.body.replace(`         ${devDescription}`, `dev      ${devDescription}`)), section.title?.startsWith('For more info') ? (section.title = color.dim('  For details on a sub-command, run'), section.body = color.dim('  $ rsbuild <command> -h')) : section.title && (section.title = color.cyan(section.title));
+        return sections;
     }), cli.parse(argv);
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.1.5\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.1.7\n`);
 }
 function setupLogLevel(argv) {
     if (argv.length <= 3) return;
@@ -10210,5 +10179,5 @@ function runCLI({ argv = process.argv } = {}) {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.1.5";
+let src_version = "2.1.7";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, mrmime_lookup, runCLI, src_logger as logger, src_version as version };